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 ApiError struct {
	ErrorCode  ErrorCode
	Message    *string
	StackTrace *string
	Details    []json.RawMessage
}

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 BackfillFeaturesOperation struct {
	// contains filtered or unexported fields
}

type BackfillFeaturesRequest struct {
	// Full names of the features to backfill.
	FeatureFullNames []string
	// Output ranges to backfill.
	BackfillRanges []BackfillRange
	// Idempotency token for the request.
	RequestId *string
}

type BackfillFeaturesResponse struct {
}

type BackfillOperationMetadata struct {
	// Full names of the features targeted by the backfill.
	FeatureFullNames []string
	// Output ranges targeted by the backfill.
	BackfillRanges []BackfillRange
	// Current state of the backfill.
	State BackfillOperationMetadata_State
}

type BackfillOperationMetadata_State string

type BackfillRange struct {
	// Start of the backfill range, inclusive. If unset, defaults to the earliest
	// source timestamp of the feature.
	StartTime *types.Time
	// End of the backfill range, exclusive. If unset, defaults to the current time.
	EndTime *types.Time
}

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 CancelOperationRequest struct {
	// The name of the operation resource to be cancelled.
	Name *string
}

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

type ColumnIdentifier struct {
	// String representation of the column name using dot-prefixed path notation.
	VariantExprPath *string `fieldmask:"variant_expr_path"`
}

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

type ContinuousWindow struct {
	// The duration of the continuous window (must be positive).
	WindowDuration *types.Duration `fieldmask:"window_duration"`
	// The offset of the continuous window (must be non-positive).
	Offset *types.Duration `fieldmask:"offset"`
}

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). The schedule is interpreted in the UTC time zone. Required when
	// mode is MANUAL (or unset). Left empty when mode is DERIVED, where the service
	// computes it (aligned to UTC) from the features' window timing and fills it in
	// on the response.
	CronExpression *string `fieldmask:"cron_expression"`
	// How the schedule is determined. Defaults to MANUAL when unset.
	Mode CronSchedule_Mode `fieldmask:"mode"`
}

type CronSchedule_Mode string

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_FeatureViewSource struct {
	FeatureViewSource FeatureViewSource `fieldmask:"feature_view_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"`
	EntityColumns    []string `fieldmask:"entity_columns"`
	TimeseriesColumn *string  `fieldmask:"timeseries_column"`
	// 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 ErrorCode 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"`
	Inputs []string    `fieldmask:"inputs"`
	// The function by which the feature is computed.
	Function   *Function   `fieldmask:"function"`
	TimeWindow *TimeWindow `fieldmask:"time_window"`
	// The description of the feature.
	Description     *string `fieldmask:"description"`
	FilterCondition *string `fieldmask:"filter_condition"`
	// 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 FeatureReference struct {
	// The three-part full name of the upstream Feature.
	Feature *string
}

type FeatureViewSource struct {
	// The upstream Features this source reads. Must include at least one feature.
	FeatureReferences []FeatureReference `fieldmask:"feature_references"`
}

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 {
	FunctionType    FunctionFunctionType     `fieldmask:"function_type"`
	ExtraParameters []FunctionExtraParameter `fieldmask:"extra_parameters"`
	Function        isFunction_Function
	// contains filtered or unexported fields
}

type FunctionExtraParameter struct {
	// The name of the parameter.
	Key *string
	// The value of the parameter.
	Value *string
}

type FunctionFunctionType string

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 GetOperationRequest struct {
	// The name of the operation resource.
	Name *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, except
	// that it may omit any columns listed in excluded_columns.
	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"`
	// Custom tags to associate with this stream's managed ingestion. They are
	// applied to the ingestion pipeline and its forward-fill and backfill jobs, and
	// forwarded to the underlying compute as cluster tags, so ingestion cost can be
	// attributed in the billing system tables. These tags apply only to the managed
	// ingestion compute; they are not applied to the Stream entity itself, and are
	// distinct from any Unity Catalog tags on the Stream. A maximum of 25 tags is
	// supported; keys and values are subject to the same limitations as cluster
	// tags.
	Tags map[string]string `fieldmask:"tags"`
	// The ID of the budget policy used to attribute the serverless compute cost of
	// this stream's managed ingestion. If not specified, a default budget policy
	// may be applied.
	BudgetPolicyId *string `fieldmask:"budget_policy_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"`
	EntityColumnIdentifiers    []ColumnIdentifier `fieldmask:"entity_column_identifiers"`
	TimeseriesColumnIdentifier *ColumnIdentifier  `fieldmask:"timeseries_column_identifier"`
	// 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. Allowed keys: - `consumerMode` - `consumerNamePrefix` -
	// `maxFetchRate` - `minFetchPeriod` - `maxFetchDuration` - `maxRecordsPerFetch`
	// - `shardsPerTask` - `fetchBufferSize` - `shardFetchInterval` `consumerMode`
	// must be `efo` or `polling` (case-insensitive). `maxRecordsPerFetch` applies
	// only during ingestion and does not affect the materialization pipeline. 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"`
	CronSchedule            *string     `fieldmask:"cron_schedule"`
	// 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
	// Name of the latest backfill operation on this materialized feature. Format:
	// operations/{operation_id}.
	LatestBackfillOperation *string `fieldmask:"latest_backfill_operation"`
	// Custom tags to associate with this materialization. They are applied to the
	// materialization job (for batch features) or pipeline (for streaming features)
	// and forwarded to the underlying compute as cluster tags, so materialization
	// cost can be attributed in the billing system tables. These tags apply only to
	// the materialization compute; they are not applied to the Unity Catalog
	// Feature resource itself, whose tags are managed separately through the Unity
	// Catalog tagging API. A maximum of 25 tags is supported; keys and values are
	// subject to the same limitations as cluster tags.
	Tags map[string]string `fieldmask:"tags"`
	// The ID of the budget policy used to attribute the serverless compute cost of
	// this materialization. If not specified, a default budget policy may be
	// applied.
	BudgetPolicyId *string `fieldmask:"budget_policy_id"`
	// 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 Operation struct {
	// The server-assigned name, which is only unique within the same service that
	// originally returns it. If you use the default HTTP mapping, the `name` should
	// be a resource name ending with `operations/{unique_id}`.
	Name *string
	// Service-specific metadata associated with the operation. It typically
	// contains progress information and common metadata such as create time. Some
	// services might not provide such metadata.
	Metadata json.RawMessage
	// If the value is `false`, it means the operation is still in progress. If
	// `true`, the operation is completed, and either `error` or `response` is
	// available.
	Done *bool
	// The operation result, which can be either an `error` or a valid `response`.
	// If `done` == `false`, neither `error` nor `response` is set. If `done` ==
	// `true`, exactly one of `error` or `response` can be set. Some services might
	// not provide the result.
	Result isOperation_Result
}

type Operation_Result_Error struct {
	Error ApiError
}

type Operation_Result_Response struct {
	Response json.RawMessage
}

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 PurgeFeatureEntitiesMetadata struct {
	// Fully qualified names of the features targeted by the purge.
	Features []string
	// Fully qualified name of the Unity Catalog Delta table containing the entity
	// keys to purge.
	EntitiesTable *string
	// Version of the entities table used by the purge.
	EntitiesTableVersion *string
	// Time at which the purge operation was created.
	CreateTime *types.Time
	// Current state of the purge operation.
	State PurgeFeatureEntitiesMetadata_State
	// ID of the job that executes this purge.
	JobId *int64
}

type PurgeFeatureEntitiesMetadata_State string

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

type PurgeFeatureEntitiesRequest struct {
	// Fully qualified names of the features to purge. At least one nonempty feature
	// name is required. A request may contain at most 10000 features; submit
	// additional features in separate requests. Duplicate features are rejected.
	Features []string
	// Source of the entity keys to purge.
	Entities isPurgeFeatureEntitiesRequest_Entities
	// Optional UUID4 idempotency token for the request.
	RequestId *string
}

type PurgeFeatureEntitiesRequest_Entities_EntitiesTable struct {
	EntitiesTable string
}

type PurgeFeatureEntitiesResponse struct {
	// Metadata about the purge operation.
	Metadata *PurgeFeatureEntitiesMetadata
	// Per-feature purge results.
	Results []PurgeFeatureEntitiesResult
	// State of the purge operation.
	State PurgeFeatureEntitiesMetadata_State
	// Operation-level error, if the purge failed outside an individual feature
	// target.
	Error *ApiError
}

type PurgeFeatureEntitiesResult struct {
	// Fully qualified name of the feature that was purged.
	Feature *string
	// State of the offline purge for this feature.
	OfflineState PurgeFeatureEntitiesResult_State
	// State of the online purge for this feature.
	OnlineState PurgeFeatureEntitiesResult_State
	// Error encountered while purging this feature, if any.
	Error *ApiError
}

type PurgeFeatureEntitiesResult_State string

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"`
	// Optional SQL predicate to filter which record types from a streaming channel
	// (e.g. a topic for Kafka) belong to this Stream. Events that do not match are
	// not written to the ingestion table and are not used in materialization.
	// Example: "value.event_type = 'transaction'".
	RecordTypeFilter *string `fieldmask:"record_type_filter"`
	// Column paths (dot notation, e.g. "value.email" for Kafka) to drop. A path may
	// reference a struct, in which case all of its nested fields are dropped (e.g.
	// "value.address" drops "value.address.city" and "value.address.zip"). These
	// columns are not written to the ingestion table and cannot be referenced by
	// any feature. They are dropped from ingestion, backfill, and materialization.
	// For direct schemas, each column must exist in the relevant key or payload
	// schema. With a schema registry, a column can be excluded before it exists. A
	// column cannot also be a deduplication column in the ingestion_config.
	ExcludedColumns []string `fieldmask:"excluded_columns"`
	// 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. Not currently supported
	// for sawtooth windows or for Features with a stream source.
	StartTime *types.Time `fieldmask:"start_time"`
	// contains filtered or unexported fields
}

type TimeWindow_WindowType_Continuous struct {
	Continuous ContinuousWindow `fieldmask:"continuous"`
}

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"`
}