@databricks/sdk-features 0.0.0-dev → 0.1.0-dev.2

package/dist/v1/model.js

@@ -0,0 +1,2253 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+import { Temporal } from '@js-temporal/polyfill';
+import { FieldMask } from '@databricks/sdk-core/wkt';
+import { z } from 'zod';
+/**
+ * Scalar data types for request-time field definitions.
+ * Only flat (non-nested) types are supported.
+ */
+export var ScalarDataType;
+(function (ScalarDataType) {
+    ScalarDataType["SCALAR_DATA_TYPE_UNSPECIFIED"] = "SCALAR_DATA_TYPE_UNSPECIFIED";
+    ScalarDataType["INTEGER"] = "INTEGER";
+    ScalarDataType["FLOAT"] = "FLOAT";
+    ScalarDataType["BOOLEAN"] = "BOOLEAN";
+    ScalarDataType["STRING"] = "STRING";
+    ScalarDataType["DOUBLE"] = "DOUBLE";
+    ScalarDataType["LONG"] = "LONG";
+    ScalarDataType["TIMESTAMP"] = "TIMESTAMP";
+    ScalarDataType["DATE"] = "DATE";
+    ScalarDataType["SHORT"] = "SHORT";
+    ScalarDataType["BINARY"] = "BINARY";
+    ScalarDataType["DECIMAL"] = "DECIMAL";
+})(ScalarDataType || (ScalarDataType = {}));
+/** Deprecated: Use the function-specific messages in AggregationFunction.function_type oneof instead. Kept for backwards compatibility. */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var Function_FunctionType;
+(function (Function_FunctionType) {
+    Function_FunctionType["FUNCTION_TYPE_UNSPECIFIED"] = "FUNCTION_TYPE_UNSPECIFIED";
+    Function_FunctionType["AVG"] = "AVG";
+    Function_FunctionType["COUNT"] = "COUNT";
+    Function_FunctionType["SUM"] = "SUM";
+    Function_FunctionType["MIN"] = "MIN";
+    Function_FunctionType["MAX"] = "MAX";
+    Function_FunctionType["FIRST"] = "FIRST";
+    Function_FunctionType["LAST"] = "LAST";
+    Function_FunctionType["APPROX_COUNT_DISTINCT"] = "APPROX_COUNT_DISTINCT";
+    Function_FunctionType["APPROX_PERCENTILE"] = "APPROX_PERCENTILE";
+    Function_FunctionType["STDDEV_POP"] = "STDDEV_POP";
+    Function_FunctionType["STDDEV_SAMP"] = "STDDEV_SAMP";
+    Function_FunctionType["VAR_POP"] = "VAR_POP";
+    Function_FunctionType["VAR_SAMP"] = "VAR_SAMP";
+})(Function_FunctionType || (Function_FunctionType = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var MaterializedFeature_PipelineScheduleState;
+(function (MaterializedFeature_PipelineScheduleState) {
+    /** Default value, not used. */
+    MaterializedFeature_PipelineScheduleState["PIPELINE_SCHEDULE_STATE_UNSPECIFIED"] = "PIPELINE_SCHEDULE_STATE_UNSPECIFIED";
+    /** Pipeline was configured to run once then stop. */
+    MaterializedFeature_PipelineScheduleState["SNAPSHOT"] = "SNAPSHOT";
+    /** Pipeline is actively running and computing features. */
+    MaterializedFeature_PipelineScheduleState["ACTIVE"] = "ACTIVE";
+    /** Pipeline is paused and not computing features. */
+    MaterializedFeature_PipelineScheduleState["PAUSED"] = "PAUSED";
+})(MaterializedFeature_PipelineScheduleState || (MaterializedFeature_PipelineScheduleState = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var StreamingMode_StreamingModeType;
+(function (StreamingMode_StreamingModeType) {
+    /** Default value, not used. */
+    StreamingMode_StreamingModeType["STREAMING_MODE_TYPE_UNSPECIFIED"] = "STREAMING_MODE_TYPE_UNSPECIFIED";
+    /**
+     * Real-time mode. Ultra-low-latency trigger intended for operational workloads
+     * that need responses in milliseconds or sub-second latency.
+     */
+    StreamingMode_StreamingModeType["STREAMING_MODE_TYPE_RTM"] = "STREAMING_MODE_TYPE_RTM";
+    /**
+     * Micro-batch mode in Structured Streaming. Better suited for ETL and analytics
+     * workloads where latency is measured in seconds or minutes and cost efficiency
+     * matters more.
+     */
+    StreamingMode_StreamingModeType["STREAMING_MODE_TYPE_MBM"] = "STREAMING_MODE_TYPE_MBM";
+})(StreamingMode_StreamingModeType || (StreamingMode_StreamingModeType = {}));
+export const unmarshalAggregationFunctionSchema = z
+    .object({
+    avg: z.lazy(() => unmarshalAvgFunctionSchema).optional(),
+    count_function: z.lazy(() => unmarshalCountFunctionSchema).optional(),
+    sum: z.lazy(() => unmarshalSumFunctionSchema).optional(),
+    min: z.lazy(() => unmarshalMinFunctionSchema).optional(),
+    max: z.lazy(() => unmarshalMaxFunctionSchema).optional(),
+    first: z.lazy(() => unmarshalFirstFunctionSchema).optional(),
+    last: z.lazy(() => unmarshalLastFunctionSchema).optional(),
+    approx_count_distinct: z
+        .lazy(() => unmarshalApproxCountDistinctFunctionSchema)
+        .optional(),
+    approx_percentile: z
+        .lazy(() => unmarshalApproxPercentileFunctionSchema)
+        .optional(),
+    stddev_pop: z.lazy(() => unmarshalStddevPopFunctionSchema).optional(),
+    stddev_samp: z.lazy(() => unmarshalStddevSampFunctionSchema).optional(),
+    var_pop: z.lazy(() => unmarshalVarPopFunctionSchema).optional(),
+    var_samp: z.lazy(() => unmarshalVarSampFunctionSchema).optional(),
+    time_window: z.lazy(() => unmarshalTimeWindowSchema).optional(),
+})
+    .transform(d => ({
+    operation: d.avg !== undefined
+        ? { $case: 'avg', avg: d.avg }
+        : d.count_function !== undefined
+            ? { $case: 'countFunction', countFunction: d.count_function }
+            : d.sum !== undefined
+                ? { $case: 'sum', sum: d.sum }
+                : d.min !== undefined
+                    ? { $case: 'min', min: d.min }
+                    : d.max !== undefined
+                        ? { $case: 'max', max: d.max }
+                        : d.first !== undefined
+                            ? { $case: 'first', first: d.first }
+                            : d.last !== undefined
+                                ? { $case: 'last', last: d.last }
+                                : d.approx_count_distinct !== undefined
+                                    ? {
+                                        $case: 'approxCountDistinct',
+                                        approxCountDistinct: d.approx_count_distinct,
+                                    }
+                                    : d.approx_percentile !== undefined
+                                        ? {
+                                            $case: 'approxPercentile',
+                                            approxPercentile: d.approx_percentile,
+                                        }
+                                        : d.stddev_pop !== undefined
+                                            ? {
+                                                $case: 'stddevPop',
+                                                stddevPop: d.stddev_pop,
+                                            }
+                                            : d.stddev_samp !== undefined
+                                                ? {
+                                                    $case: 'stddevSamp',
+                                                    stddevSamp: d.stddev_samp,
+                                                }
+                                                : d.var_pop !== undefined
+                                                    ? { $case: 'varPop', varPop: d.var_pop }
+                                                    : d.var_samp !== undefined
+                                                        ? {
+                                                            $case: 'varSamp',
+                                                            varSamp: d.var_samp,
+                                                        }
+                                                        : undefined,
+    timeWindow: d.time_window,
+}));
+export const unmarshalApproxCountDistinctFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+    relative_sd: z.number().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    relativeSd: d.relative_sd,
+}));
+export const unmarshalApproxPercentileFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+    percentile: z.number().optional(),
+    accuracy: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    percentile: d.percentile,
+    accuracy: d.accuracy,
+}));
+export const unmarshalAuthConfigSchema = z
+    .object({
+    uc_service_credential_name: z.string().optional(),
+    mtls_config: z.lazy(() => unmarshalMtlsConfigSchema).optional(),
+})
+    .transform(d => ({
+    authConfig: d.uc_service_credential_name !== undefined
+        ? {
+            $case: 'ucServiceCredentialName',
+            ucServiceCredentialName: d.uc_service_credential_name,
+        }
+        : d.mtls_config !== undefined
+            ? { $case: 'mtlsConfig', mtlsConfig: d.mtls_config }
+            : undefined,
+}));
+export const unmarshalAvgFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalBackfillSourceSchema = z
+    .object({
+    delta_table_source: z
+        .lazy(() => unmarshalDeltaTableSourceSchema)
+        .optional(),
+    delta_table_name: z.string().optional(),
+})
+    .transform(d => ({
+    backfillSource: d.delta_table_source !== undefined
+        ? {
+            $case: 'deltaTableSource',
+            deltaTableSource: d.delta_table_source,
+        }
+        : d.delta_table_name !== undefined
+            ? {
+                $case: 'deltaTableName',
+                deltaTableName: d.delta_table_name,
+            }
+            : undefined,
+}));
+export const unmarshalBatchCreateMaterializedFeaturesResponseSchema = z
+    .object({
+    materialized_features: z
+        .array(z.lazy(() => unmarshalMaterializedFeatureSchema))
+        .optional(),
+})
+    .transform(d => ({
+    materializedFeatures: d.materialized_features,
+}));
+export const unmarshalColumnIdentifierSchema = z
+    .object({
+    variant_expr_path: z.string().optional(),
+})
+    .transform(d => ({
+    variantExprPath: d.variant_expr_path,
+}));
+export const unmarshalColumnSelectionSchema = z
+    .object({
+    column: z.string().optional(),
+})
+    .transform(d => ({
+    column: d.column,
+}));
+export const unmarshalContinuousWindowSchema = z
+    .object({
+    window_duration: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+    offset: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+})
+    .transform(d => ({
+    windowDuration: d.window_duration,
+    offset: d.offset,
+}));
+export const unmarshalCountFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalCronScheduleSchema = z
+    .object({
+    cron_expression: z.string().optional(),
+})
+    .transform(d => ({
+    cronExpression: d.cron_expression,
+}));
+export const unmarshalDataSourceSchema = z
+    .object({
+    delta_table_source: z
+        .lazy(() => unmarshalDeltaTableSourceSchema)
+        .optional(),
+    kafka_source: z.lazy(() => unmarshalKafkaSourceSchema).optional(),
+    request_source: z.lazy(() => unmarshalRequestSourceSchema).optional(),
+})
+    .transform(d => ({
+    dataSource: d.delta_table_source !== undefined
+        ? {
+            $case: 'deltaTableSource',
+            deltaTableSource: d.delta_table_source,
+        }
+        : d.kafka_source !== undefined
+            ? { $case: 'kafkaSource', kafkaSource: d.kafka_source }
+            : d.request_source !== undefined
+                ? { $case: 'requestSource', requestSource: d.request_source }
+                : undefined,
+}));
+export const unmarshalDeltaTableSourceSchema = z
+    .object({
+    full_name: z.string().optional(),
+    entity_columns: z.array(z.string()).optional(),
+    timeseries_column: z.string().optional(),
+    filter_condition: z.string().optional(),
+    transformation_sql: z.string().optional(),
+    dataframe_schema: z.string().optional(),
+})
+    .transform(d => ({
+    fullName: d.full_name,
+    entityColumns: d.entity_columns,
+    timeseriesColumn: d.timeseries_column,
+    filterCondition: d.filter_condition,
+    transformationSql: d.transformation_sql,
+    dataframeSchema: d.dataframe_schema,
+}));
+export const unmarshalDirectMtlsConfigSchema = z
+    .object({
+    bootstrap_servers: z.string().optional(),
+    mtls_config: z.lazy(() => unmarshalMtlsConfigSchema).optional(),
+})
+    .transform(d => ({
+    bootstrapServers: d.bootstrap_servers,
+    mtlsConfig: d.mtls_config,
+}));
+export const unmarshalDirectSchemasSchema = z
+    .object({
+    payload_schema: z.lazy(() => unmarshalSchemaConfigSchema).optional(),
+    key_schema: z.lazy(() => unmarshalSchemaConfigSchema).optional(),
+})
+    .transform(d => ({
+    payloadSchema: d.payload_schema,
+    keySchema: d.key_schema,
+}));
+export const unmarshalEntityColumnSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const unmarshalFeatureSchema = z
+    .object({
+    full_name: z.string().optional(),
+    source: z.lazy(() => unmarshalDataSourceSchema).optional(),
+    inputs: z.array(z.string()).optional(),
+    function: z.lazy(() => unmarshalFunctionSchema).optional(),
+    time_window: z.lazy(() => unmarshalTimeWindowSchema).optional(),
+    description: z.string().optional(),
+    filter_condition: z.string().optional(),
+    lineage_context: z.lazy(() => unmarshalLineageContextSchema).optional(),
+    entities: z.array(z.lazy(() => unmarshalEntityColumnSchema)).optional(),
+    timeseries_column: z.lazy(() => unmarshalTimeseriesColumnSchema).optional(),
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    name: z.string().optional(),
+    created_at: z
+        .string()
+        .transform(s => Temporal.Instant.from(s))
+        .optional(),
+    created_by: z.string().optional(),
+})
+    .transform(d => ({
+    fullName: d.full_name,
+    source: d.source,
+    inputs: d.inputs,
+    function: d.function,
+    timeWindow: d.time_window,
+    description: d.description,
+    filterCondition: d.filter_condition,
+    lineageContext: d.lineage_context,
+    entities: d.entities,
+    timeseriesColumn: d.timeseries_column,
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    name: d.name,
+    createdAt: d.created_at,
+    createdBy: d.created_by,
+}));
+export const unmarshalFieldDefinitionSchema = z
+    .object({
+    name: z.string().optional(),
+    data_type: z.enum(ScalarDataType).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    dataType: d.data_type,
+}));
+export const unmarshalFirstFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalFlatSchemaSchema = z
+    .object({
+    fields: z.array(z.lazy(() => unmarshalFieldDefinitionSchema)).optional(),
+})
+    .transform(d => ({
+    fields: d.fields,
+}));
+export const unmarshalFunctionSchema = z
+    .object({
+    function_type: z.enum(Function_FunctionType).optional(),
+    extra_parameters: z
+        .array(z.lazy(() => unmarshalFunction_ExtraParameterSchema))
+        .optional(),
+    aggregation_function: z
+        .lazy(() => unmarshalAggregationFunctionSchema)
+        .optional(),
+    column_selection: z.lazy(() => unmarshalColumnSelectionSchema).optional(),
+})
+    .transform(d => ({
+    functionType: d.function_type,
+    extraParameters: d.extra_parameters,
+    function: d.aggregation_function !== undefined
+        ? {
+            $case: 'aggregationFunction',
+            aggregationFunction: d.aggregation_function,
+        }
+        : d.column_selection !== undefined
+            ? {
+                $case: 'columnSelection',
+                columnSelection: d.column_selection,
+            }
+            : undefined,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalFunction_ExtraParameterSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const unmarshalIngestionConfigSchema = z
+    .object({
+    ingestion_destination: z
+        .lazy(() => unmarshalIngestionDestinationSchema)
+        .optional(),
+    backfill_source: z.lazy(() => unmarshalBackfillSourceSchema).optional(),
+    deduplication_columns: z.array(z.string()).optional(),
+    ingestion_pipeline_id: z.string().optional(),
+    ingestion_job_id: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    backfill_job_id: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    ingestionDestination: d.ingestion_destination,
+    backfillSource: d.backfill_source,
+    deduplicationColumns: d.deduplication_columns,
+    ingestionPipelineId: d.ingestion_pipeline_id,
+    ingestionJobId: d.ingestion_job_id,
+    backfillJobId: d.backfill_job_id,
+}));
+export const unmarshalIngestionDestinationSchema = z
+    .object({
+    delta_table_name: z.string().optional(),
+})
+    .transform(d => ({
+    ingestionDestination: d.delta_table_name !== undefined
+        ? {
+            $case: 'deltaTableName',
+            deltaTableName: d.delta_table_name,
+        }
+        : undefined,
+}));
+export const unmarshalJobContextSchema = z
+    .object({
+    job_id: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    job_run_id: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    jobId: d.job_id,
+    jobRunId: d.job_run_id,
+}));
+export const unmarshalKafkaConfigSchema = z
+    .object({
+    name: z.string().optional(),
+    bootstrap_servers: z.string().optional(),
+    subscription_mode: z.lazy(() => unmarshalSubscriptionModeSchema).optional(),
+    auth_config: z.lazy(() => unmarshalAuthConfigSchema).optional(),
+    key_schema: z.lazy(() => unmarshalSchemaConfigSchema).optional(),
+    value_schema: z.lazy(() => unmarshalSchemaConfigSchema).optional(),
+    extra_options: z.record(z.string(), z.string()).optional(),
+    backfill_source: z.lazy(() => unmarshalBackfillSourceSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    bootstrapServers: d.bootstrap_servers,
+    subscriptionMode: d.subscription_mode,
+    authConfig: d.auth_config,
+    keySchema: d.key_schema,
+    valueSchema: d.value_schema,
+    extraOptions: d.extra_options,
+    backfillSource: d.backfill_source,
+}));
+export const unmarshalKafkaSourceSchema = z
+    .object({
+    name: z.string().optional(),
+    entity_column_identifiers: z
+        .array(z.lazy(() => unmarshalColumnIdentifierSchema))
+        .optional(),
+    timeseries_column_identifier: z
+        .lazy(() => unmarshalColumnIdentifierSchema)
+        .optional(),
+    filter_condition: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    entityColumnIdentifiers: d.entity_column_identifiers,
+    timeseriesColumnIdentifier: d.timeseries_column_identifier,
+    filterCondition: d.filter_condition,
+}));
+export const unmarshalKafkaStreamConfigSchema = z
+    .object({
+    subscription_mode: z
+        .lazy(() => unmarshalKafkaSubscriptionModeSchema)
+        .optional(),
+    extra_options: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    subscriptionMode: d.subscription_mode,
+    extraOptions: d.extra_options,
+}));
+export const unmarshalKafkaSubscriptionModeSchema = z
+    .object({
+    assign: z.string().optional(),
+    subscribe: z.string().optional(),
+    subscribe_pattern: z.string().optional(),
+})
+    .transform(d => ({
+    subscriptionMode: d.assign !== undefined
+        ? { $case: 'assign', assign: d.assign }
+        : d.subscribe !== undefined
+            ? { $case: 'subscribe', subscribe: d.subscribe }
+            : d.subscribe_pattern !== undefined
+                ? {
+                    $case: 'subscribePattern',
+                    subscribePattern: d.subscribe_pattern,
+                }
+                : undefined,
+}));
+export const unmarshalLastFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalLineageContextSchema = z
+    .object({
+    notebook_id: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    job_context: z.lazy(() => unmarshalJobContextSchema).optional(),
+})
+    .transform(d => ({
+    notebookId: d.notebook_id,
+    jobContext: d.job_context,
+}));
+export const unmarshalListFeaturesResponseSchema = z
+    .object({
+    features: z.array(z.lazy(() => unmarshalFeatureSchema)).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    features: d.features,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalListKafkaConfigsResponseSchema = z
+    .object({
+    kafka_configs: z
+        .array(z.lazy(() => unmarshalKafkaConfigSchema))
+        .optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    kafkaConfigs: d.kafka_configs,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalListMaterializedFeaturesResponseSchema = z
+    .object({
+    materialized_features: z
+        .array(z.lazy(() => unmarshalMaterializedFeatureSchema))
+        .optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    materializedFeatures: d.materialized_features,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalListStreamsResponseSchema = z
+    .object({
+    streams: z.array(z.lazy(() => unmarshalStreamSchema)).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    streams: d.streams,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalMaterializedFeatureSchema = z
+    .object({
+    materialized_feature_id: z.string().optional(),
+    feature_name: z.string().optional(),
+    offline_store_config: z
+        .lazy(() => unmarshalOfflineStoreConfigSchema)
+        .optional(),
+    online_store_config: z
+        .lazy(() => unmarshalOnlineStoreConfigSchema)
+        .optional(),
+    table_name: z.string().optional(),
+    pipeline_schedule_state: z
+        .enum(MaterializedFeature_PipelineScheduleState)
+        .optional(),
+    last_materialization_time: z
+        .string()
+        .transform(s => Temporal.Instant.from(s))
+        .optional(),
+    cron_schedule: z.string().optional(),
+    is_online: z.boolean().optional(),
+    cron_schedule_trigger: z
+        .lazy(() => unmarshalCronScheduleSchema)
+        .optional(),
+    table_trigger: z.lazy(() => unmarshalTableTriggerSchema).optional(),
+    streaming_mode: z.lazy(() => unmarshalStreamingModeSchema).optional(),
+})
+    .transform(d => ({
+    materializedFeatureId: d.materialized_feature_id,
+    featureName: d.feature_name,
+    destination: d.offline_store_config !== undefined
+        ? {
+            $case: 'offlineStoreConfig',
+            offlineStoreConfig: d.offline_store_config,
+        }
+        : d.online_store_config !== undefined
+            ? {
+                $case: 'onlineStoreConfig',
+                onlineStoreConfig: d.online_store_config,
+            }
+            : undefined,
+    tableName: d.table_name,
+    pipelineScheduleState: d.pipeline_schedule_state,
+    lastMaterializationTime: d.last_materialization_time,
+    cronSchedule: d.cron_schedule,
+    isOnline: d.is_online,
+    trigger: d.cron_schedule_trigger !== undefined
+        ? {
+            $case: 'cronScheduleTrigger',
+            cronScheduleTrigger: d.cron_schedule_trigger,
+        }
+        : d.table_trigger !== undefined
+            ? { $case: 'tableTrigger', tableTrigger: d.table_trigger }
+            : d.streaming_mode !== undefined
+                ? {
+                    $case: 'streamingMode',
+                    streamingMode: d.streaming_mode,
+                }
+                : undefined,
+}));
+export const unmarshalMaxFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalMinFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalMtlsConfigSchema = z
+    .object({
+    keystore_location: z.string().optional(),
+    keystore_password_ref: z
+        .lazy(() => unmarshalSecretScopeReferenceSchema)
+        .optional(),
+    key_password_ref: z
+        .lazy(() => unmarshalSecretScopeReferenceSchema)
+        .optional(),
+    truststore_location: z.string().optional(),
+    truststore_password_ref: z
+        .lazy(() => unmarshalSecretScopeReferenceSchema)
+        .optional(),
+    disable_hostname_verification: z.boolean().optional(),
+})
+    .transform(d => ({
+    keystoreLocation: d.keystore_location,
+    keystorePasswordRef: d.keystore_password_ref,
+    keyPasswordRef: d.key_password_ref,
+    truststoreLocation: d.truststore_location,
+    truststorePasswordRef: d.truststore_password_ref,
+    disableHostnameVerification: d.disable_hostname_verification,
+}));
+export const unmarshalOfflineStoreConfigSchema = z
+    .object({
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    table_name_prefix: z.string().optional(),
+})
+    .transform(d => ({
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    tableNamePrefix: d.table_name_prefix,
+}));
+export const unmarshalOnlineStoreConfigSchema = z
+    .object({
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    table_name_prefix: z.string().optional(),
+    online_store_name: z.string().optional(),
+})
+    .transform(d => ({
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    tableNamePrefix: d.table_name_prefix,
+    onlineStoreName: d.online_store_name,
+}));
+export const unmarshalRequestSourceSchema = z
+    .object({
+    flat_schema: z.lazy(() => unmarshalFlatSchemaSchema).optional(),
+})
+    .transform(d => ({
+    schema: d.flat_schema !== undefined
+        ? { $case: 'flatSchema', flatSchema: d.flat_schema }
+        : undefined,
+}));
+export const unmarshalRollingWindowSchema = z
+    .object({
+    window_duration: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+    delay: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+})
+    .transform(d => ({
+    windowDuration: d.window_duration,
+    delay: d.delay,
+}));
+export const unmarshalSchemaConfigSchema = z
+    .object({
+    json_schema: z.string().optional(),
+})
+    .transform(d => ({
+    schema: d.json_schema !== undefined
+        ? { $case: 'jsonSchema', jsonSchema: d.json_schema }
+        : undefined,
+}));
+export const unmarshalSecretScopeReferenceSchema = z
+    .object({
+    scope: z.string().optional(),
+    key: z.string().optional(),
+})
+    .transform(d => ({
+    scope: d.scope,
+    key: d.key,
+}));
+export const unmarshalSlidingWindowSchema = z
+    .object({
+    window_duration: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+    slide_duration: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+})
+    .transform(d => ({
+    windowDuration: d.window_duration,
+    slideDuration: d.slide_duration,
+}));
+export const unmarshalStddevPopFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalStddevSampFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalStreamSchema = z
+    .object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    source_config: z.lazy(() => unmarshalStreamSourceConfigSchema).optional(),
+    connection_config: z
+        .lazy(() => unmarshalStreamConnectionConfigSchema)
+        .optional(),
+    schema_config: z.lazy(() => unmarshalStreamSchemaConfigSchema).optional(),
+    ingestion_config: z.lazy(() => unmarshalIngestionConfigSchema).optional(),
+    create_time: z
+        .string()
+        .transform(s => Temporal.Instant.from(s))
+        .optional(),
+    created_by: z.string().optional(),
+    update_time: z
+        .string()
+        .transform(s => Temporal.Instant.from(s))
+        .optional(),
+    updated_by: z.string().optional(),
+    browse_only: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    description: d.description,
+    sourceConfig: d.source_config,
+    connectionConfig: d.connection_config,
+    schemaConfig: d.schema_config,
+    ingestionConfig: d.ingestion_config,
+    createTime: d.create_time,
+    createdBy: d.created_by,
+    updateTime: d.update_time,
+    updatedBy: d.updated_by,
+    browseOnly: d.browse_only,
+}));
+export const unmarshalStreamConnectionConfigSchema = z
+    .object({
+    uc_connection_name: z.string().optional(),
+    direct_mtls_config: z
+        .lazy(() => unmarshalDirectMtlsConfigSchema)
+        .optional(),
+})
+    .transform(d => ({
+    connectionConfig: d.uc_connection_name !== undefined
+        ? {
+            $case: 'ucConnectionName',
+            ucConnectionName: d.uc_connection_name,
+        }
+        : d.direct_mtls_config !== undefined
+            ? {
+                $case: 'directMtlsConfig',
+                directMtlsConfig: d.direct_mtls_config,
+            }
+            : undefined,
+}));
+export const unmarshalStreamSchemaConfigSchema = z
+    .object({
+    direct_schemas: z.lazy(() => unmarshalDirectSchemasSchema).optional(),
+})
+    .transform(d => ({
+    schemaConfig: d.direct_schemas !== undefined
+        ? { $case: 'directSchemas', directSchemas: d.direct_schemas }
+        : undefined,
+}));
+export const unmarshalStreamSourceConfigSchema = z
+    .object({
+    kafka_stream_config: z
+        .lazy(() => unmarshalKafkaStreamConfigSchema)
+        .optional(),
+})
+    .transform(d => ({
+    sourceConfig: d.kafka_stream_config !== undefined
+        ? {
+            $case: 'kafkaStreamConfig',
+            kafkaStreamConfig: d.kafka_stream_config,
+        }
+        : undefined,
+}));
+export const unmarshalStreamingModeSchema = z
+    .object({
+    mode: z.enum(StreamingMode_StreamingModeType).optional(),
+})
+    .transform(d => ({
+    mode: d.mode,
+}));
+export const unmarshalSubscriptionModeSchema = z
+    .object({
+    assign: z.string().optional(),
+    subscribe: z.string().optional(),
+    subscribe_pattern: z.string().optional(),
+})
+    .transform(d => ({
+    subscriptionMode: d.assign !== undefined
+        ? { $case: 'assign', assign: d.assign }
+        : d.subscribe !== undefined
+            ? { $case: 'subscribe', subscribe: d.subscribe }
+            : d.subscribe_pattern !== undefined
+                ? {
+                    $case: 'subscribePattern',
+                    subscribePattern: d.subscribe_pattern,
+                }
+                : undefined,
+}));
+export const unmarshalSumFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalTableTriggerSchema = z.object({});
+export const unmarshalTimeWindowSchema = z
+    .object({
+    continuous: z.lazy(() => unmarshalContinuousWindowSchema).optional(),
+    tumbling: z.lazy(() => unmarshalTumblingWindowSchema).optional(),
+    sliding: z.lazy(() => unmarshalSlidingWindowSchema).optional(),
+    rolling: z.lazy(() => unmarshalRollingWindowSchema).optional(),
+})
+    .transform(d => ({
+    windowType: d.continuous !== undefined
+        ? { $case: 'continuous', continuous: d.continuous }
+        : d.tumbling !== undefined
+            ? { $case: 'tumbling', tumbling: d.tumbling }
+            : d.sliding !== undefined
+                ? { $case: 'sliding', sliding: d.sliding }
+                : d.rolling !== undefined
+                    ? { $case: 'rolling', rolling: d.rolling }
+                    : undefined,
+}));
+export const unmarshalTimeseriesColumnSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const unmarshalTumblingWindowSchema = z
+    .object({
+    window_duration: z
+        .string()
+        .transform(s => Temporal.Duration.from('PT' + s.toUpperCase()))
+        .optional(),
+})
+    .transform(d => ({
+    windowDuration: d.window_duration,
+}));
+export const unmarshalVarPopFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const unmarshalVarSampFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalAggregationFunctionSchema = z
+    .object({
+    operation: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('avg'),
+            avg: z.lazy(() => marshalAvgFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('countFunction'),
+            countFunction: z.lazy(() => marshalCountFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('sum'),
+            sum: z.lazy(() => marshalSumFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('min'),
+            min: z.lazy(() => marshalMinFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('max'),
+            max: z.lazy(() => marshalMaxFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('first'),
+            first: z.lazy(() => marshalFirstFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('last'),
+            last: z.lazy(() => marshalLastFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('approxCountDistinct'),
+            approxCountDistinct: z.lazy(() => marshalApproxCountDistinctFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('approxPercentile'),
+            approxPercentile: z.lazy(() => marshalApproxPercentileFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('stddevPop'),
+            stddevPop: z.lazy(() => marshalStddevPopFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('stddevSamp'),
+            stddevSamp: z.lazy(() => marshalStddevSampFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('varPop'),
+            varPop: z.lazy(() => marshalVarPopFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('varSamp'),
+            varSamp: z.lazy(() => marshalVarSampFunctionSchema),
+        }),
+    ])
+        .optional(),
+    timeWindow: z.lazy(() => marshalTimeWindowSchema).optional(),
+})
+    .transform(d => ({
+    ...(d.operation?.$case === 'avg' && { avg: d.operation.avg }),
+    ...(d.operation?.$case === 'countFunction' && {
+        count_function: d.operation.countFunction,
+    }),
+    ...(d.operation?.$case === 'sum' && { sum: d.operation.sum }),
+    ...(d.operation?.$case === 'min' && { min: d.operation.min }),
+    ...(d.operation?.$case === 'max' && { max: d.operation.max }),
+    ...(d.operation?.$case === 'first' && { first: d.operation.first }),
+    ...(d.operation?.$case === 'last' && { last: d.operation.last }),
+    ...(d.operation?.$case === 'approxCountDistinct' && {
+        approx_count_distinct: d.operation.approxCountDistinct,
+    }),
+    ...(d.operation?.$case === 'approxPercentile' && {
+        approx_percentile: d.operation.approxPercentile,
+    }),
+    ...(d.operation?.$case === 'stddevPop' && {
+        stddev_pop: d.operation.stddevPop,
+    }),
+    ...(d.operation?.$case === 'stddevSamp' && {
+        stddev_samp: d.operation.stddevSamp,
+    }),
+    ...(d.operation?.$case === 'varPop' && { var_pop: d.operation.varPop }),
+    ...(d.operation?.$case === 'varSamp' && { var_samp: d.operation.varSamp }),
+    time_window: d.timeWindow,
+}));
+export const marshalApproxCountDistinctFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+    relativeSd: z.number().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    relative_sd: d.relativeSd,
+}));
+export const marshalApproxPercentileFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+    percentile: z.number().optional(),
+    accuracy: z.bigint().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    percentile: d.percentile,
+    accuracy: d.accuracy,
+}));
+export const marshalAuthConfigSchema = z
+    .object({
+    authConfig: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('ucServiceCredentialName'),
+            ucServiceCredentialName: z.string(),
+        }),
+        z.object({
+            $case: z.literal('mtlsConfig'),
+            mtlsConfig: z.lazy(() => marshalMtlsConfigSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.authConfig?.$case === 'ucServiceCredentialName' && {
+        uc_service_credential_name: d.authConfig.ucServiceCredentialName,
+    }),
+    ...(d.authConfig?.$case === 'mtlsConfig' && {
+        mtls_config: d.authConfig.mtlsConfig,
+    }),
+}));
+export const marshalAvgFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalBackfillSourceSchema = z
+    .object({
+    backfillSource: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('deltaTableSource'),
+            deltaTableSource: z.lazy(() => marshalDeltaTableSourceSchema),
+        }),
+        z.object({
+            $case: z.literal('deltaTableName'),
+            deltaTableName: z.string(),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.backfillSource?.$case === 'deltaTableSource' && {
+        delta_table_source: d.backfillSource.deltaTableSource,
+    }),
+    ...(d.backfillSource?.$case === 'deltaTableName' && {
+        delta_table_name: d.backfillSource.deltaTableName,
+    }),
+}));
+export const marshalBatchCreateMaterializedFeaturesRequestSchema = z
+    .object({
+    requests: z
+        .array(z.lazy(() => marshalCreateMaterializedFeatureRequestSchema))
+        .optional(),
+})
+    .transform(d => ({
+    requests: d.requests,
+}));
+export const marshalColumnIdentifierSchema = z
+    .object({
+    variantExprPath: z.string().optional(),
+})
+    .transform(d => ({
+    variant_expr_path: d.variantExprPath,
+}));
+export const marshalColumnSelectionSchema = z
+    .object({
+    column: z.string().optional(),
+})
+    .transform(d => ({
+    column: d.column,
+}));
+export const marshalContinuousWindowSchema = z
+    .object({
+    windowDuration: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+    offset: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+})
+    .transform(d => ({
+    window_duration: d.windowDuration,
+    offset: d.offset,
+}));
+export const marshalCountFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalCreateMaterializedFeatureRequestSchema = z
+    .object({
+    materializedFeature: z
+        .lazy(() => marshalMaterializedFeatureSchema)
+        .optional(),
+})
+    .transform(d => ({
+    materialized_feature: d.materializedFeature,
+}));
+export const marshalCronScheduleSchema = z
+    .object({
+    cronExpression: z.string().optional(),
+})
+    .transform(d => ({
+    cron_expression: d.cronExpression,
+}));
+export const marshalDataSourceSchema = z
+    .object({
+    dataSource: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('deltaTableSource'),
+            deltaTableSource: z.lazy(() => marshalDeltaTableSourceSchema),
+        }),
+        z.object({
+            $case: z.literal('kafkaSource'),
+            kafkaSource: z.lazy(() => marshalKafkaSourceSchema),
+        }),
+        z.object({
+            $case: z.literal('requestSource'),
+            requestSource: z.lazy(() => marshalRequestSourceSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.dataSource?.$case === 'deltaTableSource' && {
+        delta_table_source: d.dataSource.deltaTableSource,
+    }),
+    ...(d.dataSource?.$case === 'kafkaSource' && {
+        kafka_source: d.dataSource.kafkaSource,
+    }),
+    ...(d.dataSource?.$case === 'requestSource' && {
+        request_source: d.dataSource.requestSource,
+    }),
+}));
+export const marshalDeltaTableSourceSchema = z
+    .object({
+    fullName: z.string().optional(),
+    entityColumns: z.array(z.string()).optional(),
+    timeseriesColumn: z.string().optional(),
+    filterCondition: z.string().optional(),
+    transformationSql: z.string().optional(),
+    dataframeSchema: z.string().optional(),
+})
+    .transform(d => ({
+    full_name: d.fullName,
+    entity_columns: d.entityColumns,
+    timeseries_column: d.timeseriesColumn,
+    filter_condition: d.filterCondition,
+    transformation_sql: d.transformationSql,
+    dataframe_schema: d.dataframeSchema,
+}));
+export const marshalDirectMtlsConfigSchema = z
+    .object({
+    bootstrapServers: z.string().optional(),
+    mtlsConfig: z.lazy(() => marshalMtlsConfigSchema).optional(),
+})
+    .transform(d => ({
+    bootstrap_servers: d.bootstrapServers,
+    mtls_config: d.mtlsConfig,
+}));
+export const marshalDirectSchemasSchema = z
+    .object({
+    payloadSchema: z.lazy(() => marshalSchemaConfigSchema).optional(),
+    keySchema: z.lazy(() => marshalSchemaConfigSchema).optional(),
+})
+    .transform(d => ({
+    payload_schema: d.payloadSchema,
+    key_schema: d.keySchema,
+}));
+export const marshalEntityColumnSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const marshalFeatureSchema = z
+    .object({
+    fullName: z.string().optional(),
+    source: z.lazy(() => marshalDataSourceSchema).optional(),
+    inputs: z.array(z.string()).optional(),
+    function: z.lazy(() => marshalFunctionSchema).optional(),
+    timeWindow: z.lazy(() => marshalTimeWindowSchema).optional(),
+    description: z.string().optional(),
+    filterCondition: z.string().optional(),
+    lineageContext: z.lazy(() => marshalLineageContextSchema).optional(),
+    entities: z.array(z.lazy(() => marshalEntityColumnSchema)).optional(),
+    timeseriesColumn: z.lazy(() => marshalTimeseriesColumnSchema).optional(),
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    name: z.string().optional(),
+    createdAt: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    createdBy: z.string().optional(),
+})
+    .transform(d => ({
+    full_name: d.fullName,
+    source: d.source,
+    inputs: d.inputs,
+    function: d.function,
+    time_window: d.timeWindow,
+    description: d.description,
+    filter_condition: d.filterCondition,
+    lineage_context: d.lineageContext,
+    entities: d.entities,
+    timeseries_column: d.timeseriesColumn,
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    name: d.name,
+    created_at: d.createdAt,
+    created_by: d.createdBy,
+}));
+export const marshalFieldDefinitionSchema = z
+    .object({
+    name: z.string().optional(),
+    dataType: z.enum(ScalarDataType).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    data_type: d.dataType,
+}));
+export const marshalFirstFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalFlatSchemaSchema = z
+    .object({
+    fields: z.array(z.lazy(() => marshalFieldDefinitionSchema)).optional(),
+})
+    .transform(d => ({
+    fields: d.fields,
+}));
+export const marshalFunctionSchema = z
+    .object({
+    functionType: z.enum(Function_FunctionType).optional(),
+    extraParameters: z
+        .array(z.lazy(() => marshalFunction_ExtraParameterSchema))
+        .optional(),
+    function: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('aggregationFunction'),
+            aggregationFunction: z.lazy(() => marshalAggregationFunctionSchema),
+        }),
+        z.object({
+            $case: z.literal('columnSelection'),
+            columnSelection: z.lazy(() => marshalColumnSelectionSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    function_type: d.functionType,
+    extra_parameters: d.extraParameters,
+    ...(d.function?.$case === 'aggregationFunction' && {
+        aggregation_function: d.function.aggregationFunction,
+    }),
+    ...(d.function?.$case === 'columnSelection' && {
+        column_selection: d.function.columnSelection,
+    }),
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const marshalFunction_ExtraParameterSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const marshalIngestionConfigSchema = z
+    .object({
+    ingestionDestination: z
+        .lazy(() => marshalIngestionDestinationSchema)
+        .optional(),
+    backfillSource: z.lazy(() => marshalBackfillSourceSchema).optional(),
+    deduplicationColumns: z.array(z.string()).optional(),
+    ingestionPipelineId: z.string().optional(),
+    ingestionJobId: z.bigint().optional(),
+    backfillJobId: z.bigint().optional(),
+})
+    .transform(d => ({
+    ingestion_destination: d.ingestionDestination,
+    backfill_source: d.backfillSource,
+    deduplication_columns: d.deduplicationColumns,
+    ingestion_pipeline_id: d.ingestionPipelineId,
+    ingestion_job_id: d.ingestionJobId,
+    backfill_job_id: d.backfillJobId,
+}));
+export const marshalIngestionDestinationSchema = z
+    .object({
+    ingestionDestination: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('deltaTableName'),
+            deltaTableName: z.string(),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.ingestionDestination?.$case === 'deltaTableName' && {
+        delta_table_name: d.ingestionDestination.deltaTableName,
+    }),
+}));
+export const marshalJobContextSchema = z
+    .object({
+    jobId: z.bigint().optional(),
+    jobRunId: z.bigint().optional(),
+})
+    .transform(d => ({
+    job_id: d.jobId,
+    job_run_id: d.jobRunId,
+}));
+export const marshalKafkaConfigSchema = z
+    .object({
+    name: z.string().optional(),
+    bootstrapServers: z.string().optional(),
+    subscriptionMode: z.lazy(() => marshalSubscriptionModeSchema).optional(),
+    authConfig: z.lazy(() => marshalAuthConfigSchema).optional(),
+    keySchema: z.lazy(() => marshalSchemaConfigSchema).optional(),
+    valueSchema: z.lazy(() => marshalSchemaConfigSchema).optional(),
+    extraOptions: z.record(z.string(), z.string()).optional(),
+    backfillSource: z.lazy(() => marshalBackfillSourceSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    bootstrap_servers: d.bootstrapServers,
+    subscription_mode: d.subscriptionMode,
+    auth_config: d.authConfig,
+    key_schema: d.keySchema,
+    value_schema: d.valueSchema,
+    extra_options: d.extraOptions,
+    backfill_source: d.backfillSource,
+}));
+export const marshalKafkaSourceSchema = z
+    .object({
+    name: z.string().optional(),
+    entityColumnIdentifiers: z
+        .array(z.lazy(() => marshalColumnIdentifierSchema))
+        .optional(),
+    timeseriesColumnIdentifier: z
+        .lazy(() => marshalColumnIdentifierSchema)
+        .optional(),
+    filterCondition: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    entity_column_identifiers: d.entityColumnIdentifiers,
+    timeseries_column_identifier: d.timeseriesColumnIdentifier,
+    filter_condition: d.filterCondition,
+}));
+export const marshalKafkaStreamConfigSchema = z
+    .object({
+    subscriptionMode: z
+        .lazy(() => marshalKafkaSubscriptionModeSchema)
+        .optional(),
+    extraOptions: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    subscription_mode: d.subscriptionMode,
+    extra_options: d.extraOptions,
+}));
+export const marshalKafkaSubscriptionModeSchema = z
+    .object({
+    subscriptionMode: z
+        .discriminatedUnion('$case', [
+        z.object({ $case: z.literal('assign'), assign: z.string() }),
+        z.object({ $case: z.literal('subscribe'), subscribe: z.string() }),
+        z.object({
+            $case: z.literal('subscribePattern'),
+            subscribePattern: z.string(),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.subscriptionMode?.$case === 'assign' && {
+        assign: d.subscriptionMode.assign,
+    }),
+    ...(d.subscriptionMode?.$case === 'subscribe' && {
+        subscribe: d.subscriptionMode.subscribe,
+    }),
+    ...(d.subscriptionMode?.$case === 'subscribePattern' && {
+        subscribe_pattern: d.subscriptionMode.subscribePattern,
+    }),
+}));
+export const marshalLastFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalLineageContextSchema = z
+    .object({
+    notebookId: z.bigint().optional(),
+    jobContext: z.lazy(() => marshalJobContextSchema).optional(),
+})
+    .transform(d => ({
+    notebook_id: d.notebookId,
+    job_context: d.jobContext,
+}));
+export const marshalMaterializedFeatureSchema = z
+    .object({
+    materializedFeatureId: z.string().optional(),
+    featureName: z.string().optional(),
+    destination: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('offlineStoreConfig'),
+            offlineStoreConfig: z.lazy(() => marshalOfflineStoreConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('onlineStoreConfig'),
+            onlineStoreConfig: z.lazy(() => marshalOnlineStoreConfigSchema),
+        }),
+    ])
+        .optional(),
+    tableName: z.string().optional(),
+    pipelineScheduleState: z
+        .enum(MaterializedFeature_PipelineScheduleState)
+        .optional(),
+    lastMaterializationTime: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    cronSchedule: z.string().optional(),
+    isOnline: z.boolean().optional(),
+    trigger: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('cronScheduleTrigger'),
+            cronScheduleTrigger: z.lazy(() => marshalCronScheduleSchema),
+        }),
+        z.object({
+            $case: z.literal('tableTrigger'),
+            tableTrigger: z.lazy(() => marshalTableTriggerSchema),
+        }),
+        z.object({
+            $case: z.literal('streamingMode'),
+            streamingMode: z.lazy(() => marshalStreamingModeSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    materialized_feature_id: d.materializedFeatureId,
+    feature_name: d.featureName,
+    ...(d.destination?.$case === 'offlineStoreConfig' && {
+        offline_store_config: d.destination.offlineStoreConfig,
+    }),
+    ...(d.destination?.$case === 'onlineStoreConfig' && {
+        online_store_config: d.destination.onlineStoreConfig,
+    }),
+    table_name: d.tableName,
+    pipeline_schedule_state: d.pipelineScheduleState,
+    last_materialization_time: d.lastMaterializationTime,
+    cron_schedule: d.cronSchedule,
+    is_online: d.isOnline,
+    ...(d.trigger?.$case === 'cronScheduleTrigger' && {
+        cron_schedule_trigger: d.trigger.cronScheduleTrigger,
+    }),
+    ...(d.trigger?.$case === 'tableTrigger' && {
+        table_trigger: d.trigger.tableTrigger,
+    }),
+    ...(d.trigger?.$case === 'streamingMode' && {
+        streaming_mode: d.trigger.streamingMode,
+    }),
+}));
+export const marshalMaxFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalMinFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalMtlsConfigSchema = z
+    .object({
+    keystoreLocation: z.string().optional(),
+    keystorePasswordRef: z
+        .lazy(() => marshalSecretScopeReferenceSchema)
+        .optional(),
+    keyPasswordRef: z.lazy(() => marshalSecretScopeReferenceSchema).optional(),
+    truststoreLocation: z.string().optional(),
+    truststorePasswordRef: z
+        .lazy(() => marshalSecretScopeReferenceSchema)
+        .optional(),
+    disableHostnameVerification: z.boolean().optional(),
+})
+    .transform(d => ({
+    keystore_location: d.keystoreLocation,
+    keystore_password_ref: d.keystorePasswordRef,
+    key_password_ref: d.keyPasswordRef,
+    truststore_location: d.truststoreLocation,
+    truststore_password_ref: d.truststorePasswordRef,
+    disable_hostname_verification: d.disableHostnameVerification,
+}));
+export const marshalOfflineStoreConfigSchema = z
+    .object({
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableNamePrefix: z.string().optional(),
+})
+    .transform(d => ({
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_name_prefix: d.tableNamePrefix,
+}));
+export const marshalOnlineStoreConfigSchema = z
+    .object({
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableNamePrefix: z.string().optional(),
+    onlineStoreName: z.string().optional(),
+})
+    .transform(d => ({
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_name_prefix: d.tableNamePrefix,
+    online_store_name: d.onlineStoreName,
+}));
+export const marshalRequestSourceSchema = z
+    .object({
+    schema: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('flatSchema'),
+            flatSchema: z.lazy(() => marshalFlatSchemaSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.schema?.$case === 'flatSchema' && { flat_schema: d.schema.flatSchema }),
+}));
+export const marshalRollingWindowSchema = z
+    .object({
+    windowDuration: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+    delay: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+})
+    .transform(d => ({
+    window_duration: d.windowDuration,
+    delay: d.delay,
+}));
+export const marshalSchemaConfigSchema = z
+    .object({
+    schema: z
+        .discriminatedUnion('$case', [
+        z.object({ $case: z.literal('jsonSchema'), jsonSchema: z.string() }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.schema?.$case === 'jsonSchema' && { json_schema: d.schema.jsonSchema }),
+}));
+export const marshalSecretScopeReferenceSchema = z
+    .object({
+    scope: z.string().optional(),
+    key: z.string().optional(),
+})
+    .transform(d => ({
+    scope: d.scope,
+    key: d.key,
+}));
+export const marshalSlidingWindowSchema = z
+    .object({
+    windowDuration: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+    slideDuration: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+})
+    .transform(d => ({
+    window_duration: d.windowDuration,
+    slide_duration: d.slideDuration,
+}));
+export const marshalStddevPopFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalStddevSampFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalStreamSchema = z
+    .object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    sourceConfig: z.lazy(() => marshalStreamSourceConfigSchema).optional(),
+    connectionConfig: z
+        .lazy(() => marshalStreamConnectionConfigSchema)
+        .optional(),
+    schemaConfig: z.lazy(() => marshalStreamSchemaConfigSchema).optional(),
+    ingestionConfig: z.lazy(() => marshalIngestionConfigSchema).optional(),
+    createTime: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    createdBy: z.string().optional(),
+    updateTime: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    updatedBy: z.string().optional(),
+    browseOnly: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    description: d.description,
+    source_config: d.sourceConfig,
+    connection_config: d.connectionConfig,
+    schema_config: d.schemaConfig,
+    ingestion_config: d.ingestionConfig,
+    create_time: d.createTime,
+    created_by: d.createdBy,
+    update_time: d.updateTime,
+    updated_by: d.updatedBy,
+    browse_only: d.browseOnly,
+}));
+export const marshalStreamConnectionConfigSchema = z
+    .object({
+    connectionConfig: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('ucConnectionName'),
+            ucConnectionName: z.string(),
+        }),
+        z.object({
+            $case: z.literal('directMtlsConfig'),
+            directMtlsConfig: z.lazy(() => marshalDirectMtlsConfigSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.connectionConfig?.$case === 'ucConnectionName' && {
+        uc_connection_name: d.connectionConfig.ucConnectionName,
+    }),
+    ...(d.connectionConfig?.$case === 'directMtlsConfig' && {
+        direct_mtls_config: d.connectionConfig.directMtlsConfig,
+    }),
+}));
+export const marshalStreamSchemaConfigSchema = z
+    .object({
+    schemaConfig: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('directSchemas'),
+            directSchemas: z.lazy(() => marshalDirectSchemasSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.schemaConfig?.$case === 'directSchemas' && {
+        direct_schemas: d.schemaConfig.directSchemas,
+    }),
+}));
+export const marshalStreamSourceConfigSchema = z
+    .object({
+    sourceConfig: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('kafkaStreamConfig'),
+            kafkaStreamConfig: z.lazy(() => marshalKafkaStreamConfigSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.sourceConfig?.$case === 'kafkaStreamConfig' && {
+        kafka_stream_config: d.sourceConfig.kafkaStreamConfig,
+    }),
+}));
+export const marshalStreamingModeSchema = z
+    .object({
+    mode: z.enum(StreamingMode_StreamingModeType).optional(),
+})
+    .transform(d => ({
+    mode: d.mode,
+}));
+export const marshalSubscriptionModeSchema = z
+    .object({
+    subscriptionMode: z
+        .discriminatedUnion('$case', [
+        z.object({ $case: z.literal('assign'), assign: z.string() }),
+        z.object({ $case: z.literal('subscribe'), subscribe: z.string() }),
+        z.object({
+            $case: z.literal('subscribePattern'),
+            subscribePattern: z.string(),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.subscriptionMode?.$case === 'assign' && {
+        assign: d.subscriptionMode.assign,
+    }),
+    ...(d.subscriptionMode?.$case === 'subscribe' && {
+        subscribe: d.subscriptionMode.subscribe,
+    }),
+    ...(d.subscriptionMode?.$case === 'subscribePattern' && {
+        subscribe_pattern: d.subscriptionMode.subscribePattern,
+    }),
+}));
+export const marshalSumFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalTableTriggerSchema = z.object({});
+export const marshalTimeWindowSchema = z
+    .object({
+    windowType: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('continuous'),
+            continuous: z.lazy(() => marshalContinuousWindowSchema),
+        }),
+        z.object({
+            $case: z.literal('tumbling'),
+            tumbling: z.lazy(() => marshalTumblingWindowSchema),
+        }),
+        z.object({
+            $case: z.literal('sliding'),
+            sliding: z.lazy(() => marshalSlidingWindowSchema),
+        }),
+        z.object({
+            $case: z.literal('rolling'),
+            rolling: z.lazy(() => marshalRollingWindowSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.windowType?.$case === 'continuous' && {
+        continuous: d.windowType.continuous,
+    }),
+    ...(d.windowType?.$case === 'tumbling' && {
+        tumbling: d.windowType.tumbling,
+    }),
+    ...(d.windowType?.$case === 'sliding' && { sliding: d.windowType.sliding }),
+    ...(d.windowType?.$case === 'rolling' && { rolling: d.windowType.rolling }),
+}));
+export const marshalTimeseriesColumnSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const marshalTumblingWindowSchema = z
+    .object({
+    windowDuration: z
+        .any()
+        .transform((d) => d.toString().slice(2).toLowerCase())
+        .optional(),
+})
+    .transform(d => ({
+    window_duration: d.windowDuration,
+}));
+export const marshalVarPopFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+export const marshalVarSampFunctionSchema = z
+    .object({
+    input: z.string().optional(),
+})
+    .transform(d => ({
+    input: d.input,
+}));
+const aggregationFunctionFieldMaskSchema = {
+    approxCountDistinct: {
+        wire: 'approx_count_distinct',
+        children: () => approxCountDistinctFunctionFieldMaskSchema,
+    },
+    approxPercentile: {
+        wire: 'approx_percentile',
+        children: () => approxPercentileFunctionFieldMaskSchema,
+    },
+    avg: { wire: 'avg', children: () => avgFunctionFieldMaskSchema },
+    countFunction: {
+        wire: 'count_function',
+        children: () => countFunctionFieldMaskSchema,
+    },
+    first: { wire: 'first', children: () => firstFunctionFieldMaskSchema },
+    last: { wire: 'last', children: () => lastFunctionFieldMaskSchema },
+    max: { wire: 'max', children: () => maxFunctionFieldMaskSchema },
+    min: { wire: 'min', children: () => minFunctionFieldMaskSchema },
+    stddevPop: {
+        wire: 'stddev_pop',
+        children: () => stddevPopFunctionFieldMaskSchema,
+    },
+    stddevSamp: {
+        wire: 'stddev_samp',
+        children: () => stddevSampFunctionFieldMaskSchema,
+    },
+    sum: { wire: 'sum', children: () => sumFunctionFieldMaskSchema },
+    timeWindow: { wire: 'time_window', children: () => timeWindowFieldMaskSchema },
+    varPop: { wire: 'var_pop', children: () => varPopFunctionFieldMaskSchema },
+    varSamp: { wire: 'var_samp', children: () => varSampFunctionFieldMaskSchema },
+};
+const approxCountDistinctFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+    relativeSd: { wire: 'relative_sd' },
+};
+const approxPercentileFunctionFieldMaskSchema = {
+    accuracy: { wire: 'accuracy' },
+    input: { wire: 'input' },
+    percentile: { wire: 'percentile' },
+};
+const authConfigFieldMaskSchema = {
+    mtlsConfig: { wire: 'mtls_config', children: () => mtlsConfigFieldMaskSchema },
+    ucServiceCredentialName: { wire: 'uc_service_credential_name' },
+};
+const avgFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const backfillSourceFieldMaskSchema = {
+    deltaTableName: { wire: 'delta_table_name' },
+    deltaTableSource: {
+        wire: 'delta_table_source',
+        children: () => deltaTableSourceFieldMaskSchema,
+    },
+};
+const columnIdentifierFieldMaskSchema = {
+    variantExprPath: { wire: 'variant_expr_path' },
+};
+const columnSelectionFieldMaskSchema = {
+    column: { wire: 'column' },
+};
+const continuousWindowFieldMaskSchema = {
+    offset: { wire: 'offset' },
+    windowDuration: { wire: 'window_duration' },
+};
+const countFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const cronScheduleFieldMaskSchema = {
+    cronExpression: { wire: 'cron_expression' },
+};
+const dataSourceFieldMaskSchema = {
+    deltaTableSource: {
+        wire: 'delta_table_source',
+        children: () => deltaTableSourceFieldMaskSchema,
+    },
+    kafkaSource: {
+        wire: 'kafka_source',
+        children: () => kafkaSourceFieldMaskSchema,
+    },
+    requestSource: {
+        wire: 'request_source',
+        children: () => requestSourceFieldMaskSchema,
+    },
+};
+const deltaTableSourceFieldMaskSchema = {
+    dataframeSchema: { wire: 'dataframe_schema' },
+    entityColumns: { wire: 'entity_columns' },
+    filterCondition: { wire: 'filter_condition' },
+    fullName: { wire: 'full_name' },
+    timeseriesColumn: { wire: 'timeseries_column' },
+    transformationSql: { wire: 'transformation_sql' },
+};
+const directMtlsConfigFieldMaskSchema = {
+    bootstrapServers: { wire: 'bootstrap_servers' },
+    mtlsConfig: { wire: 'mtls_config', children: () => mtlsConfigFieldMaskSchema },
+};
+const directSchemasFieldMaskSchema = {
+    keySchema: { wire: 'key_schema', children: () => schemaConfigFieldMaskSchema },
+    payloadSchema: {
+        wire: 'payload_schema',
+        children: () => schemaConfigFieldMaskSchema,
+    },
+};
+const featureFieldMaskSchema = {
+    catalogName: { wire: 'catalog_name' },
+    createdAt: { wire: 'created_at' },
+    createdBy: { wire: 'created_by' },
+    description: { wire: 'description' },
+    entities: { wire: 'entities' },
+    filterCondition: { wire: 'filter_condition' },
+    fullName: { wire: 'full_name' },
+    function: { wire: 'function', children: () => functionFieldMaskSchema },
+    inputs: { wire: 'inputs' },
+    lineageContext: {
+        wire: 'lineage_context',
+        children: () => lineageContextFieldMaskSchema,
+    },
+    name: { wire: 'name' },
+    schemaName: { wire: 'schema_name' },
+    source: { wire: 'source', children: () => dataSourceFieldMaskSchema },
+    timeWindow: { wire: 'time_window', children: () => timeWindowFieldMaskSchema },
+    timeseriesColumn: {
+        wire: 'timeseries_column',
+        children: () => timeseriesColumnFieldMaskSchema,
+    },
+};
+export function featureFieldMask(...paths) {
+    return FieldMask.build(paths, featureFieldMaskSchema);
+}
+const firstFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const flatSchemaFieldMaskSchema = {
+    fields: { wire: 'fields' },
+};
+const functionFieldMaskSchema = {
+    aggregationFunction: {
+        wire: 'aggregation_function',
+        children: () => aggregationFunctionFieldMaskSchema,
+    },
+    columnSelection: {
+        wire: 'column_selection',
+        children: () => columnSelectionFieldMaskSchema,
+    },
+    extraParameters: { wire: 'extra_parameters' },
+    functionType: { wire: 'function_type' },
+};
+const ingestionConfigFieldMaskSchema = {
+    backfillJobId: { wire: 'backfill_job_id' },
+    backfillSource: {
+        wire: 'backfill_source',
+        children: () => backfillSourceFieldMaskSchema,
+    },
+    deduplicationColumns: { wire: 'deduplication_columns' },
+    ingestionDestination: {
+        wire: 'ingestion_destination',
+        children: () => ingestionDestinationFieldMaskSchema,
+    },
+    ingestionJobId: { wire: 'ingestion_job_id' },
+    ingestionPipelineId: { wire: 'ingestion_pipeline_id' },
+};
+const ingestionDestinationFieldMaskSchema = {
+    deltaTableName: { wire: 'delta_table_name' },
+};
+const jobContextFieldMaskSchema = {
+    jobId: { wire: 'job_id' },
+    jobRunId: { wire: 'job_run_id' },
+};
+const kafkaConfigFieldMaskSchema = {
+    authConfig: { wire: 'auth_config', children: () => authConfigFieldMaskSchema },
+    backfillSource: {
+        wire: 'backfill_source',
+        children: () => backfillSourceFieldMaskSchema,
+    },
+    bootstrapServers: { wire: 'bootstrap_servers' },
+    extraOptions: { wire: 'extra_options' },
+    keySchema: { wire: 'key_schema', children: () => schemaConfigFieldMaskSchema },
+    name: { wire: 'name' },
+    subscriptionMode: {
+        wire: 'subscription_mode',
+        children: () => subscriptionModeFieldMaskSchema,
+    },
+    valueSchema: {
+        wire: 'value_schema',
+        children: () => schemaConfigFieldMaskSchema,
+    },
+};
+export function kafkaConfigFieldMask(...paths) {
+    return FieldMask.build(paths, kafkaConfigFieldMaskSchema);
+}
+const kafkaSourceFieldMaskSchema = {
+    entityColumnIdentifiers: { wire: 'entity_column_identifiers' },
+    filterCondition: { wire: 'filter_condition' },
+    name: { wire: 'name' },
+    timeseriesColumnIdentifier: {
+        wire: 'timeseries_column_identifier',
+        children: () => columnIdentifierFieldMaskSchema,
+    },
+};
+const kafkaStreamConfigFieldMaskSchema = {
+    extraOptions: { wire: 'extra_options' },
+    subscriptionMode: {
+        wire: 'subscription_mode',
+        children: () => kafkaSubscriptionModeFieldMaskSchema,
+    },
+};
+const kafkaSubscriptionModeFieldMaskSchema = {
+    assign: { wire: 'assign' },
+    subscribe: { wire: 'subscribe' },
+    subscribePattern: { wire: 'subscribe_pattern' },
+};
+const lastFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const lineageContextFieldMaskSchema = {
+    jobContext: { wire: 'job_context', children: () => jobContextFieldMaskSchema },
+    notebookId: { wire: 'notebook_id' },
+};
+const materializedFeatureFieldMaskSchema = {
+    cronSchedule: { wire: 'cron_schedule' },
+    cronScheduleTrigger: {
+        wire: 'cron_schedule_trigger',
+        children: () => cronScheduleFieldMaskSchema,
+    },
+    featureName: { wire: 'feature_name' },
+    isOnline: { wire: 'is_online' },
+    lastMaterializationTime: { wire: 'last_materialization_time' },
+    materializedFeatureId: { wire: 'materialized_feature_id' },
+    offlineStoreConfig: {
+        wire: 'offline_store_config',
+        children: () => offlineStoreConfigFieldMaskSchema,
+    },
+    onlineStoreConfig: {
+        wire: 'online_store_config',
+        children: () => onlineStoreConfigFieldMaskSchema,
+    },
+    pipelineScheduleState: { wire: 'pipeline_schedule_state' },
+    streamingMode: {
+        wire: 'streaming_mode',
+        children: () => streamingModeFieldMaskSchema,
+    },
+    tableName: { wire: 'table_name' },
+    tableTrigger: {
+        wire: 'table_trigger',
+        children: () => tableTriggerFieldMaskSchema,
+    },
+};
+export function materializedFeatureFieldMask(...paths) {
+    return FieldMask.build(paths, materializedFeatureFieldMaskSchema);
+}
+const maxFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const minFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const mtlsConfigFieldMaskSchema = {
+    disableHostnameVerification: { wire: 'disable_hostname_verification' },
+    keyPasswordRef: {
+        wire: 'key_password_ref',
+        children: () => secretScopeReferenceFieldMaskSchema,
+    },
+    keystoreLocation: { wire: 'keystore_location' },
+    keystorePasswordRef: {
+        wire: 'keystore_password_ref',
+        children: () => secretScopeReferenceFieldMaskSchema,
+    },
+    truststoreLocation: { wire: 'truststore_location' },
+    truststorePasswordRef: {
+        wire: 'truststore_password_ref',
+        children: () => secretScopeReferenceFieldMaskSchema,
+    },
+};
+const offlineStoreConfigFieldMaskSchema = {
+    catalogName: { wire: 'catalog_name' },
+    schemaName: { wire: 'schema_name' },
+    tableNamePrefix: { wire: 'table_name_prefix' },
+};
+const onlineStoreConfigFieldMaskSchema = {
+    catalogName: { wire: 'catalog_name' },
+    onlineStoreName: { wire: 'online_store_name' },
+    schemaName: { wire: 'schema_name' },
+    tableNamePrefix: { wire: 'table_name_prefix' },
+};
+const requestSourceFieldMaskSchema = {
+    flatSchema: { wire: 'flat_schema', children: () => flatSchemaFieldMaskSchema },
+};
+const rollingWindowFieldMaskSchema = {
+    delay: { wire: 'delay' },
+    windowDuration: { wire: 'window_duration' },
+};
+const schemaConfigFieldMaskSchema = {
+    jsonSchema: { wire: 'json_schema' },
+};
+const secretScopeReferenceFieldMaskSchema = {
+    key: { wire: 'key' },
+    scope: { wire: 'scope' },
+};
+const slidingWindowFieldMaskSchema = {
+    slideDuration: { wire: 'slide_duration' },
+    windowDuration: { wire: 'window_duration' },
+};
+const stddevPopFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const stddevSampFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const streamFieldMaskSchema = {
+    browseOnly: { wire: 'browse_only' },
+    connectionConfig: {
+        wire: 'connection_config',
+        children: () => streamConnectionConfigFieldMaskSchema,
+    },
+    createTime: { wire: 'create_time' },
+    createdBy: { wire: 'created_by' },
+    description: { wire: 'description' },
+    ingestionConfig: {
+        wire: 'ingestion_config',
+        children: () => ingestionConfigFieldMaskSchema,
+    },
+    name: { wire: 'name' },
+    schemaConfig: {
+        wire: 'schema_config',
+        children: () => streamSchemaConfigFieldMaskSchema,
+    },
+    sourceConfig: {
+        wire: 'source_config',
+        children: () => streamSourceConfigFieldMaskSchema,
+    },
+    updateTime: { wire: 'update_time' },
+    updatedBy: { wire: 'updated_by' },
+};
+export function streamFieldMask(...paths) {
+    return FieldMask.build(paths, streamFieldMaskSchema);
+}
+const streamConnectionConfigFieldMaskSchema = {
+    directMtlsConfig: {
+        wire: 'direct_mtls_config',
+        children: () => directMtlsConfigFieldMaskSchema,
+    },
+    ucConnectionName: { wire: 'uc_connection_name' },
+};
+const streamSchemaConfigFieldMaskSchema = {
+    directSchemas: {
+        wire: 'direct_schemas',
+        children: () => directSchemasFieldMaskSchema,
+    },
+};
+const streamSourceConfigFieldMaskSchema = {
+    kafkaStreamConfig: {
+        wire: 'kafka_stream_config',
+        children: () => kafkaStreamConfigFieldMaskSchema,
+    },
+};
+const streamingModeFieldMaskSchema = {
+    mode: { wire: 'mode' },
+};
+const subscriptionModeFieldMaskSchema = {
+    assign: { wire: 'assign' },
+    subscribe: { wire: 'subscribe' },
+    subscribePattern: { wire: 'subscribe_pattern' },
+};
+const sumFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const tableTriggerFieldMaskSchema = {};
+const timeWindowFieldMaskSchema = {
+    continuous: {
+        wire: 'continuous',
+        children: () => continuousWindowFieldMaskSchema,
+    },
+    rolling: { wire: 'rolling', children: () => rollingWindowFieldMaskSchema },
+    sliding: { wire: 'sliding', children: () => slidingWindowFieldMaskSchema },
+    tumbling: { wire: 'tumbling', children: () => tumblingWindowFieldMaskSchema },
+};
+const timeseriesColumnFieldMaskSchema = {
+    name: { wire: 'name' },
+};
+const tumblingWindowFieldMaskSchema = {
+    windowDuration: { wire: 'window_duration' },
+};
+const varPopFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+const varSampFunctionFieldMaskSchema = {
+    input: { wire: 'input' },
+};
+//# sourceMappingURL=model.js.map