features

type AggregationFunction struct {
	// The type of the aggregation function.
	Operation isAggregationFunction_Operation
	// The time window over which the aggregation is computed.
	TimeWindow *TimeWindow `fieldmask:"time_window"`
	// contains filtered or unexported fields
}

type AggregationFunction_Operation_ApproxCountDistinct struct {
	ApproxCountDistinct ApproxCountDistinctFunction `fieldmask:"approx_count_distinct"`
}

type AggregationFunction_Operation_ApproxPercentile struct {
	ApproxPercentile ApproxPercentileFunction `fieldmask:"approx_percentile"`
}

type AggregationFunction_Operation_Avg struct {
	Avg AvgFunction `fieldmask:"avg"`
}

type AggregationFunction_Operation_CountFunction struct {
	CountFunction CountFunction `fieldmask:"count_function"`
}

type AggregationFunction_Operation_First struct {
	First FirstFunction `fieldmask:"first"`
}

type AggregationFunction_Operation_FirstDistinct struct {
	FirstDistinct FirstDistinctFunction `fieldmask:"first_distinct"`
}

type AggregationFunction_Operation_FirstN struct {
	FirstN FirstNFunction `fieldmask:"first_n"`
}

type AggregationFunction_Operation_Last struct {
	Last LastFunction `fieldmask:"last"`
}

type AggregationFunction_Operation_LastDistinct struct {
	LastDistinct LastDistinctFunction `fieldmask:"last_distinct"`
}

type AggregationFunction_Operation_LastN struct {
	LastN LastNFunction `fieldmask:"last_n"`
}

type AggregationFunction_Operation_Max struct {
	Max MaxFunction `fieldmask:"max"`
}

type AggregationFunction_Operation_Min struct {
	Min MinFunction `fieldmask:"min"`
}

type AggregationFunction_Operation_StddevPop struct {
	StddevPop StddevPopFunction `fieldmask:"stddev_pop"`
}

type AggregationFunction_Operation_StddevSamp struct {
	StddevSamp StddevSampFunction `fieldmask:"stddev_samp"`
}

type AggregationFunction_Operation_Sum struct {
	Sum SumFunction `fieldmask:"sum"`
}

type AggregationFunction_Operation_VarPop struct {
	VarPop VarPopFunction `fieldmask:"var_pop"`
}

type AggregationFunction_Operation_VarSamp struct {
	VarSamp VarSampFunction `fieldmask:"var_samp"`
}

type ApproxCountDistinctFunction struct {
	// The input column from which the approximate count of distinct values is
	// computed.
	Input *string `fieldmask:"input"`
	// The maximum relative standard deviation allowed (default defined by Spark).
	RelativeSd *float64 `fieldmask:"relative_sd"`
}

type ApproxPercentileFunction struct {
	// The input column from which the approximate percentile is computed.
	Input *string `fieldmask:"input"`
	// The percentile value to compute (between 0 and 1).
	Percentile *float64 `fieldmask:"percentile"`
	// The accuracy parameter (higher is more accurate but slower).
	Accuracy *int64 `fieldmask:"accuracy"`
}

type AuthConfig struct {
	AuthConfig isAuthConfig_AuthConfig
	// contains filtered or unexported fields
}

type AuthConfig_AuthConfig_MtlsConfig struct {
	MtlsConfig MtlsConfig `fieldmask:"mtls_config"`
}

type AuthConfig_AuthConfig_UcServiceCredentialName struct {
	UcServiceCredentialName string `fieldmask:"uc_service_credential_name"`
}

type AvgFunction struct {
	// The input column from which the average is computed. For Kafka sources, use
	// dot-prefixed path notation (e.g., "value.amount"). For nested fields, the
	// leaf node name is used. Colon-prefixed notation (e.g., "value:amount") is
	// supported for backwards compatibility but is deprecated; migrate to dot
	// notation.
	Input *string `fieldmask:"input"`
}

type BackfillSource struct {
	BackfillSource isBackfillSource_BackfillSource
	// contains filtered or unexported fields
}

type BackfillSource_BackfillSource_DeltaTableName struct {
	DeltaTableName string `fieldmask:"delta_table_name"`
}

type BackfillSource_BackfillSource_DeltaTableSource struct {
	DeltaTableSource DeltaTableSource `fieldmask:"delta_table_source"`
}

type BatchCreateMaterializedFeaturesRequest struct {
	// The requests to create materialized features.
	Requests []CreateMaterializedFeatureRequest
}

type BatchCreateMaterializedFeaturesResponse struct {
	// The created materialized features with assigned IDs.
	MaterializedFeatures []MaterializedFeature
}

type Client struct {
	// contains filtered or unexported fields
}

type ColumnSelection struct {
	// Column name from source to select as the feature value.
	Column *string `fieldmask:"column"`
}

type CountFunction struct {
	// The input column from which the count is computed. For Kafka sources, use
	// dot-prefixed path notation (e.g., "value.amount"). For nested fields, the
	// leaf node name is used. Colon-prefixed notation (e.g., "value:amount") is
	// supported for backwards compatibility but is deprecated; migrate to dot
	// notation.
	Input *string `fieldmask:"input"`
}

type CreateFeatureRequest struct {
	// Feature to create.
	Feature *Feature
}

type CreateKafkaConfigRequest struct {
	KafkaConfig *KafkaConfig
}

type CreateMaterializedFeatureRequest struct {
	// The materialized feature to create.
	MaterializedFeature *MaterializedFeature
}

type CreateStreamRequest struct {
	// The Stream to create.
	Stream *Stream
}

type CronSchedule struct {
	// The cron expression defining the schedule (e.g., "0 0 * * *" for daily at
	// midnight).
	CronExpression *string `fieldmask:"cron_expression"`
}

type CustomUdf struct {
	// Fully qualified 3-part Unity Catalog path of the function to apply.
	FunctionPath *string `fieldmask:"function_path"`
	// Binds each UC function parameter to a source column. May be empty for
	// zero-argument functions (e.g. a timestamp generator).
	InputBindings []InputBinding `fieldmask:"input_bindings"`
}

type DataSource struct {
	DataSource isDataSource_DataSource
	// Completeness timing for this Feature's use of the source. This configuration
	// is part of the Feature definition; it does not modify the underlying table or
	// stream.
	Lateness *SourceLateness `fieldmask:"lateness"`
	// contains filtered or unexported fields
}

type DataSource_DataSource_DeltaTableSource struct {
	DeltaTableSource DeltaTableSource `fieldmask:"delta_table_source"`
}

type DataSource_DataSource_KafkaSource struct {
	KafkaSource KafkaSource `fieldmask:"kafka_source"`
}

type DataSource_DataSource_RequestSource struct {
	RequestSource RequestSource `fieldmask:"request_source"`
}

type DataSource_DataSource_StreamSource struct {
	StreamSource StreamSource `fieldmask:"stream_source"`
}

type DeleteFeatureRequest struct {
	// Name of the feature to delete.
	FullName *string
}

type DeleteKafkaConfigRequest struct {
	// Name of the Kafka config to delete.
	Name *string
}

type DeleteMaterializedFeatureRequest struct {
	// The ID of the materialized feature to delete.
	MaterializedFeatureId *string
}

type DeleteStreamRequest struct {
	// Full three-part name (catalog.schema.stream) of the Stream to delete.
	Name *string
}

type DeltaTableSource struct {
	// The full three-part (catalog, schema, table) name of the Delta table.
	FullName *string `fieldmask:"full_name"`
	// Single WHERE clause to filter delta table before applying transformations.
	// Will be row-wise evaluated, so should only include conditionals and
	// projections.
	FilterCondition *string `fieldmask:"filter_condition"`
	// A single SQL SELECT expression applied after filter_condition. Should
	// contains all the columns needed (eg. "SELECT *, col_a + col_b AS col_c FROM
	// x.y.z WHERE col_a > 0" would have `transformation_sql` "*, col_a + col_b AS
	// col_c") If transformation_sql is not provided, all columns of the delta table
	// are present in the DataSource dataframe.
	TransformationSql *string `fieldmask:"transformation_sql"`
	// Schema of the resulting dataframe after transformations, in Spark StructType
	// JSON format (from df.schema.json()). Required if transformation_sql is
	// specified. Example:
	// {"type":"struct","fields":[{"name":"col_a","type":"integer","nullable":true,"metadata":{}},{"name":"col_c","type":"integer","nullable":true,"metadata":{}}]}
	DataframeSchema *string `fieldmask:"dataframe_schema"`
}

type DirectMtlsConfig struct {
	// A comma-separated list of host:port pairs for the Kafka bootstrap servers.
	BootstrapServers *string `fieldmask:"bootstrap_servers"`
	// Mutual-TLS authentication configuration.
	MtlsConfig *MtlsConfig `fieldmask:"mtls_config"`
}

type DirectSchemas struct {
	// Schema for the message payload. For Kafka, this is the value schema. Unless
	// the platform supports another schema (e.g. keys for Kafka), this must be
	// specified.
	PayloadSchema *SchemaConfig `fieldmask:"payload_schema"`
	// Schema for the message key. This is only used for Kafka streams. For Kafka,
	// at least one of payload_schema or key_schema must be specified.
	KeySchema *SchemaConfig `fieldmask:"key_schema"`
}

type EntityColumn struct {
	// The name of the entity column. For Kafka sources, use dot-prefixed path
	// notation to reference fields within the key or value schema (e.g.,
	// "value.user_id", "key.partition_key"). For nested fields, the leaf node name
	// (e.g., "user_id" from "value.trip_details.user_id") is what will be present
	// in materialized tables and expected to match at query time. Colon-prefixed
	// notation (e.g., "value:user_id") is supported for backwards compatibility but
	// is deprecated; migrate to dot notation.
	Name *string
}

type Feature struct {
	// The full three-part name (catalog, schema, name) of the feature. This is the
	// feature's resource identifier; the catalog_name, schema_name, and name fields
	// below are OUTPUT_ONLY decomposed views of this value.
	FullName *string `fieldmask:"full_name"`
	// The data source of the feature.
	Source *DataSource `fieldmask:"source"`
	// The function by which the feature is computed.
	Function *Function `fieldmask:"function"`
	// The description of the feature.
	Description *string `fieldmask:"description"`
	// Lineage context information for this feature. WARNING: This field is
	// primarily intended for internal use by <Databricks> systems and is
	// automatically populated when features are created through <Databricks>
	// notebooks or jobs. Users should not manually set this field as incorrect
	// values may lead to inaccurate lineage tracking or unexpected behavior. This
	// field will be set by feature-engineering client and should be left unset by
	// SDK and terraform users.
	LineageContext *LineageContext `fieldmask:"lineage_context"`
	// The entity columns for the feature, used as aggregation keys and for
	// query-time lookup.
	Entities []EntityColumn `fieldmask:"entities"`
	// Column recording time, used for point-in-time joins, backfills, and
	// aggregations.
	TimeseriesColumn *TimeseriesColumn `fieldmask:"timeseries_column"`
	// Name of parent catalog.
	CatalogName *string `fieldmask:"catalog_name"`
	// Name of parent schema relative to its parent catalog.
	SchemaName *string `fieldmask:"schema_name"`
	// Name of the feature, extracted from the full three-part name
	// (catalog.schema.name).
	Name *string `fieldmask:"name"`
	// Time at which this feature was created.
	CreatedAt *types.Time `fieldmask:"created_at"`
	// Username of the feature creator.
	CreatedBy *string `fieldmask:"created_by"`
}

type FieldDefinition struct {
	// The name of the field.
	Name *string
	// The scalar data type of the field.
	DataType ScalarDataType
}

type FirstDistinctFunction struct {
	// The input column from which the first N distinct values are returned.
	Input *string `fieldmask:"input"`
	// The number of distinct values to return.
	N *int64 `fieldmask:"n"`
}

type FirstFunction struct {
	// The input column from which the first value is returned.
	Input *string `fieldmask:"input"`
}

type FirstNFunction struct {
	// The input column from which the first N values are returned.
	Input *string `fieldmask:"input"`
	// The number of values to return.
	N *int64 `fieldmask:"n"`
}

type FlatSchema struct {
	// The list of fields in this schema.
	Fields []FieldDefinition `fieldmask:"fields"`
}

type Function struct {
	Function isFunction_Function
	// contains filtered or unexported fields
}

type Function_Function_AggregationFunction struct {
	AggregationFunction AggregationFunction `fieldmask:"aggregation_function"`
}

type Function_Function_ColumnSelection struct {
	ColumnSelection ColumnSelection `fieldmask:"column_selection"`
}

type Function_Function_CustomUdf struct {
	CustomUdf CustomUdf `fieldmask:"custom_udf"`
}

type GetFeatureRequest struct {
	// Name of the feature to get.
	FullName *string
}

type GetKafkaConfigRequest struct {
	// Name of the Kafka config to get.
	Name *string
}

type GetMaterializedFeatureRequest struct {
	// The ID of the materialized feature.
	MaterializedFeatureId *string
}

type GetStreamRequest struct {
	// Full three-part name (catalog.schema.stream) of the Stream to get.
	Name *string
}

type IngestionConfig struct {
	// Destination for the <Databricks>-managed Delta table that holds an offline
	// copy of the streaming data for querying and training. This table contains
	// both 1) forward-filled data from the Stream and 2) backfilled data from the
	// BackfillSource (if provided). This table is created and managed by
	// <Databricks> and is deleted when the Stream is deleted.
	IngestionDestination *IngestionDestination `fieldmask:"ingestion_destination"`
	// A user-provided source for backfilling data. Historical data is used when
	// creating a training set from streaming features linked to this Stream. The
	// backfill data stored in this location will be copied into the ingestion table
	// for offline querying and training. The schema for this source must match
	// exactly that of the key and payload schemas specified for this Stream.
	BackfillSource *BackfillSource `fieldmask:"backfill_source"`
	// Column paths used to identify duplicate rows during ingestion; only one row
	// per distinct combination of these values is kept. Use dot notation for nested
	// fields (e.g. `value.user_id`). Empty list means every column is compared.
	DeduplicationColumns []string `fieldmask:"deduplication_columns"`
	// The ID of the SDP pipeline that continuously copies new events from the
	// streaming source into the ingestion Delta table.
	IngestionPipelineId *string `fieldmask:"ingestion_pipeline_id"`
	// The ID of the Databricks Job that performs the forward-fill ingestion.
	IngestionJobId *int64 `fieldmask:"ingestion_job_id"`
	// The ID of the Databricks Job that performs the historical backfill of the
	// ingestion Delta table.
	BackfillJobId *int64 `fieldmask:"backfill_job_id"`
}

type IngestionDestination struct {
	IngestionDestination isIngestionDestination_IngestionDestination
	// contains filtered or unexported fields
}

type IngestionDestination_IngestionDestination_DeltaTableName struct {
	DeltaTableName string `fieldmask:"delta_table_name"`
}

type InputBinding struct {
	// Name of the UC function parameter.
	Parameter *string
	// Source column whose value is passed for this parameter at execution time.
	Column *string
}

type JobContext struct {
	// The job ID where this API invoked.
	JobId *int64 `fieldmask:"job_id"`
	// The job run ID where this API was invoked.
	JobRunId *int64 `fieldmask:"job_run_id"`
}

type KafkaConfig struct {
	// Name that uniquely identifies this Kafka config within the metastore. This
	// will be the identifier used from the Feature object to reference these
	// configs for a feature. Can be distinct from topic name.
	Name *string `fieldmask:"name"`
	// A comma-separated list of host/port pairs pointing to Kafka cluster.
	BootstrapServers *string `fieldmask:"bootstrap_servers"`
	// Options to configure which Kafka topics to pull data from.
	SubscriptionMode *SubscriptionMode `fieldmask:"subscription_mode"`
	// Authentication configuration for connection to topics.
	AuthConfig *AuthConfig `fieldmask:"auth_config"`
	// Schema configuration for extracting message keys from topics. At least one of
	// key_schema and value_schema must be provided.
	KeySchema *SchemaConfig `fieldmask:"key_schema"`
	// Schema configuration for extracting message values from topics. At least one
	// of key_schema and value_schema must be provided.
	ValueSchema *SchemaConfig `fieldmask:"value_schema"`
	// Catch-all for miscellaneous options. Keys should be source options or Kafka
	// consumer options (kafka.*)
	ExtraOptions map[string]string `fieldmask:"extra_options"`
	// A user-provided and managed source for backfilling data. Historical data is
	// used when creating a training set from streaming features linked to this
	// Kafka config. In the future, a separate table will be maintained by
	// <Databricks> for forward filling data. The schema for this source must match
	// exactly that of the key and value schemas specified for this Kafka config.
	BackfillSource *BackfillSource `fieldmask:"backfill_source"`
	// Configuration for ingesting Kafka data into a <Databricks>-managed Delta
	// table.
	IngestionConfig *IngestionConfig `fieldmask:"ingestion_config"`
}

type KafkaSource struct {
	// Name of the Kafka source, used to identify it. This is used to look up the
	// corresponding KafkaConfig object. Can be distinct from topic name.
	Name *string `fieldmask:"name"`
	// The filter condition applied to the source data before aggregation.
	FilterCondition *string `fieldmask:"filter_condition"`
}

type KafkaStreamConfig struct {
	// Options to configure which Kafka topics to pull data from.
	SubscriptionMode *KafkaSubscriptionMode `fieldmask:"subscription_mode"`
	// Optional Kafka source or consumer options, validated against a server-side
	// allowlist at request time. Allowed keys: - `maxOffsetsPerTrigger` -
	// `startingOffsets` - `includeHeaders` - `kafka.request.timeout.ms` -
	// `kafka.session.timeout.ms` - `kafka.max.partition.fetch.bytes` The following
	// keys are ingestion-only and are stripped before being forwarded to the
	// materialization pipeline: - `maxOffsetsPerTrigger` - `startingOffsets` Auth
	// and connection details belong on the parent Stream's `connection_config`, not
	// here.
	ExtraOptions map[string]string `fieldmask:"extra_options"`
}

type KafkaSubscriptionMode struct {
	// These match the settings from
	// https://spark.apache.org/docs/latest/streaming/structured-streaming-kafka-integration.html
	SubscriptionMode isKafkaSubscriptionMode_SubscriptionMode
	// contains filtered or unexported fields
}

type KafkaSubscriptionMode_SubscriptionMode_Assign struct {
	Assign string `fieldmask:"assign"`
}

type KafkaSubscriptionMode_SubscriptionMode_Subscribe struct {
	Subscribe string `fieldmask:"subscribe"`
}

type KafkaSubscriptionMode_SubscriptionMode_SubscribePattern struct {
	SubscribePattern string `fieldmask:"subscribe_pattern"`
}

type KinesisStreamConfig struct {
	// Identifies the Kinesis data stream(s) to read from. Set exactly one of
	// stream_names or stream_arns (identify the streams by name or by ARN, but not
	// both). A single Stream may read from one or more Kinesis streams.
	StreamIdentifier isKinesisStreamConfig_StreamIdentifier
	// Optional Kinesis source options, validated against a server-side allowlist at
	// request time. Auth and connection details belong on the parent Stream's
	// `connection_config`, not here.
	ExtraOptions map[string]string `fieldmask:"extra_options"`
	// contains filtered or unexported fields
}

type KinesisStreamConfig_StreamIdentifier_StreamArns struct {
	StreamArns StreamArnList `fieldmask:"stream_arns"`
}

type KinesisStreamConfig_StreamIdentifier_StreamNames struct {
	StreamNames StreamNameList `fieldmask:"stream_names"`
}

type LastDistinctFunction struct {
	// The input column from which the last N distinct values are returned.
	Input *string `fieldmask:"input"`
	// The number of distinct values to return.
	N *int64 `fieldmask:"n"`
}

type LastFunction struct {
	// The input column from which the last value is returned.
	Input *string `fieldmask:"input"`
}

type LastNFunction struct {
	// The input column from which the last N values are returned.
	Input *string `fieldmask:"input"`
	// The number of values to return.
	N *int64 `fieldmask:"n"`
}

type LineageContext struct {
	// The notebook ID where this API was invoked.
	NotebookId *int64 `fieldmask:"notebook_id"`
	// Job context information including job ID and run ID.
	JobContext *JobContext `fieldmask:"job_context"`
}

type ListFeaturesRequest struct {
	// Pagination token to go to the next page based on a previous query.
	PageToken *string
	// The maximum number of results to return.
	PageSize *int
	// Name of parent catalog for features of interest.
	CatalogName *string
	// Name of parent schema relative to its parent catalog.
	SchemaName *string
}

type ListFeaturesResponse struct {
	// List of features.
	Features []Feature
	// Pagination token to request the next page of results for this query.
	NextPageToken *string
}

type ListKafkaConfigsRequest struct {
	// Pagination token to go to the next page based on a previous query.
	PageToken *string
	// The maximum number of results to return.
	PageSize *int
}

type ListKafkaConfigsResponse struct {
	// List of Kafka configs. Schemas are not included in the response.
	KafkaConfigs []KafkaConfig
	// Pagination token to request the next page of results for this query.
	NextPageToken *string
}

type ListMaterializedFeaturesRequest struct {
	// Filter by feature name. If specified, only materialized features materialized
	// from this feature will be returned.
	FeatureName *string
	// Pagination token to go to the next page based on a previous query.
	PageToken *string
	// The maximum number of results to return. Defaults to 100 if not specified.
	// Cannot be greater than 1000.
	PageSize *int
}

type ListMaterializedFeaturesResponse struct {
	// List of materialized features.
	MaterializedFeatures []MaterializedFeature
	// Pagination token to request the next page of results for this query.
	NextPageToken *string
}

type ListStreamsRequest struct {
	// Two-part name (catalog.schema) of the parent under which to list Streams.
	Parent *string
	// The maximum number of results to return.
	PageSize *int
	// Pagination token to go to the next page based on a previous query.
	PageToken *string
}

type ListStreamsResponse struct {
	// List of Streams.
	Streams []Stream
	// Pagination token to request the next page of results for this query.
	NextPageToken *string
}

type MaterializedFeature struct {
	// Server-assigned unique identifier for the materialized feature.
	MaterializedFeatureId *string `fieldmask:"materialized_feature_id"`
	// The full name of the feature in Unity Catalog.
	FeatureName *string `fieldmask:"feature_name"`
	Destination isMaterializedFeature_Destination
	// The fully qualified Unity Catalog path to the table containing the
	// materialized feature (Delta table or Lakebase table). Output only.
	TableName *string `fieldmask:"table_name"`
	// The schedule state of the materialization pipeline. Hidden from GraphQL:
	// being deprecated, so not exposed to Catalog Explorer.
	PipelineScheduleState MaterializedFeature_PipelineScheduleState `fieldmask:"pipeline_schedule_state"`
	// The timestamp when the pipeline last ran and updated the materialized feature
	// values. If the pipeline has not run yet, this field will be null.
	LastMaterializationTime *types.Time `fieldmask:"last_materialization_time"`
	// True if this is an online materialized feature. False if it is an offline
	// materialized feature.
	IsOnline *bool `fieldmask:"is_online"`
	// The trigger configuration for the materialization pipeline.
	Trigger isMaterializedFeature_Trigger
	// contains filtered or unexported fields
}

type MaterializedFeature_Destination_OfflineStoreConfig struct {
	OfflineStoreConfig OfflineStoreConfig `fieldmask:"offline_store_config"`
}

type MaterializedFeature_Destination_OnlineStoreConfig struct {
	OnlineStoreConfig OnlineStoreConfig `fieldmask:"online_store_config"`
}

type MaterializedFeature_PipelineScheduleState string

type MaterializedFeature_Trigger_CronScheduleTrigger struct {
	CronScheduleTrigger CronSchedule `fieldmask:"cron_schedule_trigger"`
}

type MaterializedFeature_Trigger_StreamingMode struct {
	StreamingMode StreamingMode `fieldmask:"streaming_mode"`
}

type MaterializedFeature_Trigger_TableTrigger struct {
	TableTrigger TableTrigger `fieldmask:"table_trigger"`
}

type MaxFunction struct {
	// The input column from which the maximum is computed.
	Input *string `fieldmask:"input"`
}

type MinFunction struct {
	// The input column from which the minimum is computed.
	Input *string `fieldmask:"input"`
}

type MtlsConfig struct {
	// Unity Catalog volume path to the JKS keystore file containing the client
	// certificate and private key. e.g.
	// "/Volumes/<catalog>/<schema>/<volume>/client.jks". The materialization
	// compute must have read permission on this volume.
	KeystoreLocation *string `fieldmask:"keystore_location"`
	// Secret-scope reference for the JKS keystore password.
	KeystorePasswordRef *SecretScopeReference `fieldmask:"keystore_password_ref"`
	// Secret-scope reference for the private key password. Often the same value as
	// the keystore password (keytool's default), but provided as a separate field
	// because Apache Kafka requires it as a distinct option
	// (kafka.ssl.key.password).
	KeyPasswordRef *SecretScopeReference `fieldmask:"key_password_ref"`
	// Unity Catalog volume path to the JKS truststore file containing the CA
	// certificate(s) trusted to verify the Kafka broker's server certificate. e.g.
	// "/Volumes/<catalog>/<schema>/<volume>/truststore.jks".
	TruststoreLocation *string `fieldmask:"truststore_location"`
	// Secret-scope reference for the JKS truststore password.
	TruststorePasswordRef *SecretScopeReference `fieldmask:"truststore_password_ref"`
	// Set to true only when the broker certificate's SAN intentionally does not
	// match the connection endpoint — for example when reaching the cluster
	// through a PrivateLink endpoint whose DNS name is not in the broker
	// certificate. Skipping the hostname check removes a defense against
	// man-in-the-middle attacks; do not enable casually. mTLS client authentication
	// is unaffected by this option.
	//
	// See the Apache Kafka SSL security guide for background on this check:
	// https://kafka.apache.org/42/security/encryption-and-authentication-using-ssl/#host-name-verification
	DisableHostnameVerification *bool `fieldmask:"disable_hostname_verification"`
}

type OfflineStoreConfig struct {
	// The Unity Catalog catalog name.
	CatalogName *string `fieldmask:"catalog_name"`
	// The Unity Catalog schema name.
	SchemaName *string `fieldmask:"schema_name"`
	// Prefix for Unity Catalog table name. The materialized feature will be stored
	// in a table with this prefix and a generated postfix.
	TableNamePrefix *string `fieldmask:"table_name_prefix"`
}

type OnlineStoreConfig struct {
	// The Unity Catalog catalog name. This name is also used as the Lakebase
	// logical database name. Quoting is handled by the backend where needed, do not
	// pre-quote it.
	CatalogName *string `fieldmask:"catalog_name"`
	// The Unity Catalog schema name. This name is also used as the Lakebase schema
	// name under the database. Quoting is handled by the backend where needed, do
	// not pre-quote it.
	SchemaName *string `fieldmask:"schema_name"`
	// Prefix for Unity Catalog table name. The materialized feature will be stored
	// in a Lakebase table with this prefix and a generated postfix.
	TableNamePrefix *string `fieldmask:"table_name_prefix"`
	// The name of the target online store.
	OnlineStoreName *string `fieldmask:"online_store_name"`
}

type ProtoSchemaSpec struct {
	// The raw .proto file text (proto2 and proto3 syntax supported, see
	// https://protobuf.dev/programming-guides/proto3/ and
	// https://protobuf.dev/programming-guides/proto2/).
	SchemaText *string `fieldmask:"schema_text"`
	// The fully-qualified name of the message within schema_text that describes the
	// Kafka payload (e.g. "Event" or "com.example.Event" if schema_text declares a
	// package). Identifies which message is used to decode each Kafka record — a
	// .proto file may declare multiple messages but only one represents the
	// payload. Must not be empty.
	MessageName *string `fieldmask:"message_name"`
}

type RequestSource struct {
	// The schema describing the request-time fields. Currently only flat schemas
	// are supported.
	Schema isRequestSource_Schema
	// contains filtered or unexported fields
}

type RequestSource_Schema_FlatSchema struct {
	FlatSchema FlatSchema `fieldmask:"flat_schema"`
}

type RollingWindow struct {
	// The duration of the rolling window. Must be positive when set; absent means
	// lifetime (aggregate over the entity's entire history).
	WindowDuration *types.Duration `fieldmask:"window_duration"`
	// Non-negative analytic lag that evaluates the window this far in the past. Use
	// this for timing variations unrelated to source lateness, such as a 30-day
	// count as of one week ago. If unset, the analytic lag is zero. It composes
	// with source.lateness when both are set.
	Delay *types.Duration `fieldmask:"delay"`
}

type SawtoothWindow struct {
	// The duration of the window. Must be positive and span more than two days when
	// set, so that both the batch (N-1 day) and stale-path (N-2 day) partial
	// aggregates are well defined. The duration need not be a whole number of days
	// (e.g. 3 days 15 minutes is allowed). Absent means lifetime (aggregate over
	// the entity's entire history).
	WindowDuration *types.Duration `fieldmask:"window_duration"`
	// Delay is not currently supported for Sawtooth windows.
	Delay *types.Duration `fieldmask:"delay"`
}

type ScalarDataType string

type SchemaConfig struct {
	Schema isSchemaConfig_Schema
	// contains filtered or unexported fields
}

type SchemaConfig_Schema_AvroSchema struct {
	AvroSchema string `fieldmask:"avro_schema"`
}

type SchemaConfig_Schema_JsonSchema struct {
	JsonSchema string `fieldmask:"json_schema"`
}

type SchemaConfig_Schema_ProtoSchema struct {
	ProtoSchema ProtoSchemaSpec `fieldmask:"proto_schema"`
}

type SchemaLocator struct {
	// Registry-specific schema locator.
	RegistrySchema isSchemaLocator_RegistrySchema
	// Serialization format for this schema.
	Format SchemaLocator_Format `fieldmask:"format"`
	// contains filtered or unexported fields
}

type SchemaLocator_ConfluentSchema struct {
	// The Confluent schema registry subject name.
	Subject *string `fieldmask:"subject"`
}

type SchemaLocator_Format string

type SchemaLocator_RegistrySchema_ConfluentSchema struct {
	ConfluentSchema SchemaLocator_ConfluentSchema `fieldmask:"confluent_schema"`
}

type SchemaRegistryConfig struct {
	// A Schema Registry UC Connection object.
	UcConnection *string `fieldmask:"uc_connection"`
	// Reference to the schema registry API secret in a <Databricks> secret scope.
	ApiSecretRef *SecretScopeReference `fieldmask:"api_secret_ref"`
	// Schema locator for the message payload. For Kafka this is the value. At least
	// one of payload_schema_locator or key_schema_locator must be set.
	PayloadSchemaLocator *SchemaLocator `fieldmask:"payload_schema_locator"`
	// Schema locator for the message key. Only used for Kafka streams. At least one
	// of payload_schema_locator or key_schema_locator must be set.
	KeySchemaLocator *SchemaLocator `fieldmask:"key_schema_locator"`
}

type SecretScopeReference struct {
	// The <Databricks> secret scope name.
	Scope *string `fieldmask:"scope"`
	// The key within the scope.
	Key *string `fieldmask:"key"`
}

type SlidingWindow struct {
	// The duration of the sliding window. Must be positive when set; absent means
	// lifetime (aggregate over the entity's entire history).
	WindowDuration *types.Duration `fieldmask:"window_duration"`
	// The slide duration (interval by which windows advance, must be positive and
	// less than duration).
	SlideDuration *types.Duration `fieldmask:"slide_duration"`
	// Non-negative analytic lag that evaluates the window this far in the past. Use
	// this for timing variations unrelated to source lateness, such as a 30-day
	// count as of one week ago. If unset, the analytic lag is zero. It composes
	// with source.lateness when both are set.
	Delay *types.Duration `fieldmask:"delay"`
	// Non-negative phase shift from the default midnight UTC alignment. For
	// example, offset=22h on a 24h slide produces boundaries at 22:00 UTC (17:00
	// New York in standard time) instead of midnight UTC. If unset, the offset is
	// zero. Must be shorter than slide_duration (and therefore window_duration).
	Offset *types.Duration `fieldmask:"offset"`
}

type SourceLateness struct {
	// Non-negative time to wait after a window ends before treating its source data
	// as complete. Training shifts the eligible evaluation time backwards by this
	// duration so it does not join data that would still have been settling online.
	// Materialization waits for the duration to elapse before publishing the
	// window. If unset, source data is considered settled immediately.
	SettlingDelay *types.Duration `fieldmask:"settling_delay"`
}

type StddevPopFunction struct {
	// The input column from which the population standard deviation is computed.
	// For Kafka sources, use dot-prefixed path notation (e.g., "value.amount"). For
	// nested fields, the leaf node name is used. Colon-prefixed notation (e.g.,
	// "value:amount") is supported for backwards compatibility but is deprecated;
	// migrate to dot notation.
	Input *string `fieldmask:"input"`
}

type StddevSampFunction struct {
	// The input column from which the sample standard deviation is computed.
	Input *string `fieldmask:"input"`
}

type Stream struct {
	// Full three-part (catalog.schema.stream) name of the stream.
	Name *string `fieldmask:"name"`
	// User-provided description.
	Description *string `fieldmask:"description"`
	// Source-specific configuration. Determines the streaming platform source.
	SourceConfig *StreamSourceConfig `fieldmask:"source_config"`
	// Specifies how to connect and authenticate to the stream platform.
	ConnectionConfig *StreamConnectionConfig `fieldmask:"connection_config"`
	// Schema definitions for the stream, provided either directly on the Stream or
	// resolved from an external schema registry through a UC Connection.
	SchemaConfig *StreamSchemaConfig `fieldmask:"schema_config"`
	// Configuration for streaming data ingestion: the managed table storing an
	// offline copy of forward fill data and optional historical backfill.
	IngestionConfig *IngestionConfig `fieldmask:"ingestion_config"`
	// Time at which this Stream was created.
	CreateTime *types.Time `fieldmask:"create_time"`
	// Username of the Stream creator.
	CreatedBy *string `fieldmask:"created_by"`
	// Time at which this Stream was last modified.
	UpdateTime *types.Time `fieldmask:"update_time"`
	// Username of user who last modified the Stream.
	UpdatedBy *string `fieldmask:"updated_by"`
	// Indicates whether the principal is limited to retrieving metadata for the
	// associated object through the BROWSE privilege when include_browse is enabled
	// in the request.
	BrowseOnly *bool `fieldmask:"browse_only"`
}

type StreamArnList struct {
	// Kinesis stream ARNs to read from. For example,
	// 'arn:aws:kinesis:us-west-2:111122223333:stream/stream-a'.
	Arns []string `fieldmask:"arns"`
}

type StreamConnectionConfig struct {
	ConnectionConfig isStreamConnectionConfig_ConnectionConfig
	// contains filtered or unexported fields
}

type StreamConnectionConfig_ConnectionConfig_DirectMtlsConfig struct {
	DirectMtlsConfig DirectMtlsConfig `fieldmask:"direct_mtls_config"`
}

type StreamConnectionConfig_ConnectionConfig_UcConnectionName struct {
	UcConnectionName string `fieldmask:"uc_connection_name"`
}

type StreamNameList struct {
	// Kinesis stream names to read from.
	Names []string `fieldmask:"names"`
}

type StreamSchemaConfig struct {
	SchemaConfig isStreamSchemaConfig_SchemaConfig
	// contains filtered or unexported fields
}

type StreamSchemaConfig_SchemaConfig_DirectSchemas struct {
	DirectSchemas DirectSchemas `fieldmask:"direct_schemas"`
}

type StreamSchemaConfig_SchemaConfig_SchemaRegistryConfig struct {
	SchemaRegistryConfig SchemaRegistryConfig `fieldmask:"schema_registry_config"`
}

type StreamSource struct {
	// Three-part full name of the Stream (catalog.schema.stream).
	FullName *string `fieldmask:"full_name"`
	// The filter condition applied to the source data before aggregation.
	FilterCondition *string `fieldmask:"filter_condition"`
	// The pipeline runs these SQL statements immediately after conversion into the
	// schema specified on the Stream object.
	TransformationSql *string `fieldmask:"transformation_sql"`
	// Schema of the resulting dataframe after transformations, in Spark StructType
	// JSON format (from df.schema.json()). Any subsequent functions operate against
	// this dataframe.
	DataframeSchema *string `fieldmask:"dataframe_schema"`
}

type StreamSourceConfig struct {
	SourceConfig isStreamSourceConfig_SourceConfig
	// contains filtered or unexported fields
}

type StreamSourceConfig_SourceConfig_KafkaStreamConfig struct {
	KafkaStreamConfig KafkaStreamConfig `fieldmask:"kafka_stream_config"`
}

type StreamSourceConfig_SourceConfig_KinesisStreamConfig struct {
	KinesisStreamConfig KinesisStreamConfig `fieldmask:"kinesis_stream_config"`
}

type StreamingMode struct {
	// The type of streaming mode used by the materialization pipeline.
	Mode StreamingMode_StreamingModeType `fieldmask:"mode"`
	// The desired data freshness for feature materialization, expressed as a
	// duration string (e.g. "1 minute").
	FreshnessTarget *string `fieldmask:"freshness_target"`
}

type StreamingMode_StreamingModeType string

type SubscriptionMode_SubscriptionMode_Assign struct {
	Assign string `fieldmask:"assign"`
}

type SubscriptionMode_SubscriptionMode_Subscribe struct {
	Subscribe string `fieldmask:"subscribe"`
}

type SubscriptionMode_SubscriptionMode_SubscribePattern struct {
	SubscribePattern string `fieldmask:"subscribe_pattern"`
}

type SumFunction struct {
	// The input column from which the sum is computed. For Kafka sources, use
	// dot-prefixed path notation (e.g., "value.amount"). For nested fields, the
	// leaf node name is used. Colon-prefixed notation (e.g., "value:amount") is
	// supported for backwards compatibility but is deprecated; migrate to dot
	// notation.
	Input *string `fieldmask:"input"`
}

type TableTrigger struct {
}

type TimeWindow struct {
	WindowType isTimeWindow_WindowType
	// Earliest event-time boundary at which the Feature may emit an output. This
	// gates outputs, not the historical inputs read by a window. For example, a
	// 365-day window with start_time=2026-01-01 begins emitting partial-window
	// values on that date instead of waiting for 365 days of data; a lifetime
	// window produces no output before start_time. If unset, tumbling and
	// fixed-duration sliding windows first emit at an offset-aligned boundary after
	// a full window can be formed. If unset, lifetime sliding windows and rolling
	// windows emit as soon as eligible source data exists.
	StartTime *types.Time `fieldmask:"start_time"`
	// contains filtered or unexported fields
}

type TimeWindow_WindowType_Rolling struct {
	Rolling RollingWindow `fieldmask:"rolling"`
}

type TimeWindow_WindowType_Sawtooth struct {
	Sawtooth SawtoothWindow `fieldmask:"sawtooth"`
}

type TimeWindow_WindowType_Sliding struct {
	Sliding SlidingWindow `fieldmask:"sliding"`
}

type TimeWindow_WindowType_Tumbling struct {
	Tumbling TumblingWindow `fieldmask:"tumbling"`
}

type TimeseriesColumn struct {
	// The name of the timeseries column. For Kafka sources, use dot-prefixed path
	// notation to reference fields within the key or value schema (e.g.,
	// "value.event_timestamp"). For nested fields, the leaf node name (e.g.,
	// "event_timestamp" from "value.event_details.event_timestamp") is what will be
	// present in materialized tables and expected to match at query time.
	// Colon-prefixed notation (e.g., "value:event_timestamp") is supported for
	// backwards compatibility but is deprecated; migrate to dot notation.
	Name *string `fieldmask:"name"`
}

type TumblingWindow struct {
	// The duration of each tumbling window (non-overlapping, fixed-duration
	// windows).
	WindowDuration *types.Duration `fieldmask:"window_duration"`
	// Non-negative analytic lag that evaluates the window this far in the past. Use
	// this for timing variations unrelated to source lateness, such as a 30-day
	// count as of one week ago. If unset, the analytic lag is zero. It composes
	// with source.lateness when both are set.
	Delay *types.Duration `fieldmask:"delay"`
	// Non-negative phase shift from the default midnight UTC alignment. For
	// example, offset=22h on a 24h window produces boundaries at 22:00 UTC (17:00
	// New York in standard time) instead of midnight UTC. If unset, the offset is
	// zero. Must be shorter than window_duration.
	Offset *types.Duration `fieldmask:"offset"`
}

type UpdateFeatureRequest struct {
	// Feature to update.
	Feature *Feature
	// The list of fields to update.
	UpdateMask *types.FieldMask[Feature]
}

type UpdateKafkaConfigRequest struct {
	// The Kafka config to update.
	KafkaConfig *KafkaConfig
	// The list of fields to update.
	UpdateMask *types.FieldMask[KafkaConfig]
}

type UpdateMaterializedFeatureRequest struct {
	// The materialized feature to update.
	MaterializedFeature *MaterializedFeature
	// Provide the materialization feature fields which should be updated.
	// Currently, only the pipeline_state field can be updated.
	UpdateMask *types.FieldMask[MaterializedFeature]
}

type UpdateStreamRequest struct {
	// The Stream to update.
	Stream *Stream
	// The list of fields to update.
	UpdateMask *types.FieldMask[Stream]
}

type VarPopFunction struct {
	// The input column from which the population variance is computed.
	Input *string `fieldmask:"input"`
}

type VarSampFunction struct {
	// The input column from which the sample variance is computed.
	Input *string `fieldmask:"input"`
}