@databricks/sdk-uc-tables 0.0.0-dev → 0.1.0-dev.1

package/dist/v1/model.js

@@ -0,0 +1,1103 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+import { z } from 'zod';
+export var ColumnTypeName;
+(function (ColumnTypeName) {
+    ColumnTypeName["BOOLEAN"] = "BOOLEAN";
+    ColumnTypeName["BYTE"] = "BYTE";
+    ColumnTypeName["SHORT"] = "SHORT";
+    ColumnTypeName["INT"] = "INT";
+    ColumnTypeName["LONG"] = "LONG";
+    ColumnTypeName["FLOAT"] = "FLOAT";
+    ColumnTypeName["DOUBLE"] = "DOUBLE";
+    ColumnTypeName["DATE"] = "DATE";
+    ColumnTypeName["TIMESTAMP"] = "TIMESTAMP";
+    ColumnTypeName["STRING"] = "STRING";
+    ColumnTypeName["BINARY"] = "BINARY";
+    ColumnTypeName["DECIMAL"] = "DECIMAL";
+    ColumnTypeName["INTERVAL"] = "INTERVAL";
+    ColumnTypeName["ARRAY"] = "ARRAY";
+    ColumnTypeName["STRUCT"] = "STRUCT";
+    ColumnTypeName["MAP"] = "MAP";
+    ColumnTypeName["CHAR"] = "CHAR";
+    ColumnTypeName["NULL"] = "NULL";
+    ColumnTypeName["USER_DEFINED_TYPE"] = "USER_DEFINED_TYPE";
+    ColumnTypeName["TIMESTAMP_NTZ"] = "TIMESTAMP_NTZ";
+    ColumnTypeName["VARIANT"] = "VARIANT";
+    ColumnTypeName["GEOMETRY"] = "GEOMETRY";
+    ColumnTypeName["GEOGRAPHY"] = "GEOGRAPHY";
+    ColumnTypeName["TABLE_TYPE"] = "TABLE_TYPE";
+})(ColumnTypeName || (ColumnTypeName = {}));
+/** Data source format */
+export var DataSourceFormat;
+(function (DataSourceFormat) {
+    DataSourceFormat["DELTA"] = "DELTA";
+    DataSourceFormat["CSV"] = "CSV";
+    DataSourceFormat["JSON"] = "JSON";
+    DataSourceFormat["AVRO"] = "AVRO";
+    DataSourceFormat["PARQUET"] = "PARQUET";
+    DataSourceFormat["ORC"] = "ORC";
+    DataSourceFormat["TEXT"] = "TEXT";
+    DataSourceFormat["UNITY_CATALOG"] = "UNITY_CATALOG";
+    /** A table shared through Delta Sharing protocol. */
+    DataSourceFormat["DELTASHARING"] = "DELTASHARING";
+    /** BEGIN - Query federation data source formats. */
+    DataSourceFormat["DATABRICKS_FORMAT"] = "DATABRICKS_FORMAT";
+    DataSourceFormat["MYSQL_FORMAT"] = "MYSQL_FORMAT";
+    DataSourceFormat["ORACLE_FORMAT"] = "ORACLE_FORMAT";
+    DataSourceFormat["POSTGRESQL_FORMAT"] = "POSTGRESQL_FORMAT";
+    DataSourceFormat["REDSHIFT_FORMAT"] = "REDSHIFT_FORMAT";
+    DataSourceFormat["SNOWFLAKE_FORMAT"] = "SNOWFLAKE_FORMAT";
+    DataSourceFormat["SQLDW_FORMAT"] = "SQLDW_FORMAT";
+    DataSourceFormat["SQLSERVER_FORMAT"] = "SQLSERVER_FORMAT";
+    DataSourceFormat["SALESFORCE_FORMAT"] = "SALESFORCE_FORMAT";
+    DataSourceFormat["SALESFORCE_DATA_CLOUD_FORMAT"] = "SALESFORCE_DATA_CLOUD_FORMAT";
+    DataSourceFormat["TERADATA_FORMAT"] = "TERADATA_FORMAT";
+    DataSourceFormat["BIGQUERY_FORMAT"] = "BIGQUERY_FORMAT";
+    DataSourceFormat["NETSUITE_FORMAT"] = "NETSUITE_FORMAT";
+    DataSourceFormat["WORKDAY_RAAS_FORMAT"] = "WORKDAY_RAAS_FORMAT";
+    DataSourceFormat["MONGODB_FORMAT"] = "MONGODB_FORMAT";
+    /** datasource format used for hive tables. */
+    DataSourceFormat["HIVE"] = "HIVE";
+    /**
+     * END - Query federation data source formats.
+     * Vector search managed index format
+     */
+    DataSourceFormat["VECTOR_INDEX_FORMAT"] = "VECTOR_INDEX_FORMAT";
+    /** Brickstore managed online row-oriented storage format. */
+    DataSourceFormat["DATABRICKS_ROW_STORE_FORMAT"] = "DATABRICKS_ROW_STORE_FORMAT";
+    /** Uniform storage format for Hudi */
+    DataSourceFormat["DELTA_UNIFORM_HUDI"] = "DELTA_UNIFORM_HUDI";
+    /** Uniform storage format for Iceberg */
+    DataSourceFormat["DELTA_UNIFORM_ICEBERG"] = "DELTA_UNIFORM_ICEBERG";
+    /** Apache Iceberg DataFormat */
+    DataSourceFormat["ICEBERG"] = "ICEBERG";
+})(DataSourceFormat || (DataSourceFormat = {}));
+/**
+ * Latest kind: CONNECTION_GOOGLE_CLOUD_LAKEHOUSE_SERVICE_ACCOUNT = 340; Next id: 342.
+ * Reserved numbers: 316, 317, 327, 330 (former ENDPOINT_LLM_*,
+ * MODEL_SERVICE_STANDARD, MODEL_SERVICE_SYSTEM_DELTASHARING).
+ */
+export var SecurableKind;
+(function (SecurableKind) {
+    SecurableKind["TABLE_STANDARD"] = "TABLE_STANDARD";
+    SecurableKind["TABLE_EXTERNAL"] = "TABLE_EXTERNAL";
+    SecurableKind["TABLE_DELTA"] = "TABLE_DELTA";
+    SecurableKind["TABLE_DELTA_EXTERNAL"] = "TABLE_DELTA_EXTERNAL";
+    SecurableKind["TABLE_VIEW"] = "TABLE_VIEW";
+    SecurableKind["TABLE_METRIC_VIEW"] = "TABLE_METRIC_VIEW";
+    SecurableKind["TABLE_DELTASHARING"] = "TABLE_DELTASHARING";
+    SecurableKind["TABLE_DELTASHARING_MUTABLE"] = "TABLE_DELTASHARING_MUTABLE";
+    SecurableKind["TABLE_VIEW_DELTASHARING"] = "TABLE_VIEW_DELTASHARING";
+    SecurableKind["TABLE_METRIC_VIEW_DELTASHARING"] = "TABLE_METRIC_VIEW_DELTASHARING";
+    SecurableKind["TABLE_MATERIALIZED_VIEW_DELTASHARING"] = "TABLE_MATERIALIZED_VIEW_DELTASHARING";
+    SecurableKind["TABLE_STREAMING_LIVE_TABLE_DELTASHARING"] = "TABLE_STREAMING_LIVE_TABLE_DELTASHARING";
+    SecurableKind["TABLE_FOREIGN_DELTASHARING"] = "TABLE_FOREIGN_DELTASHARING";
+    SecurableKind["TABLE_DELTA_ICEBERG_DELTASHARING"] = "TABLE_DELTA_ICEBERG_DELTASHARING";
+    SecurableKind["TABLE_DELTASHARING_OPEN_DIR_BASED"] = "TABLE_DELTASHARING_OPEN_DIR_BASED";
+    /** TABLE_FEATURE_STORE and TABLE_FEATURE_STORE_EXTERNAL are deprecated. */
+    SecurableKind["TABLE_FEATURE_STORE"] = "TABLE_FEATURE_STORE";
+    SecurableKind["TABLE_FEATURE_STORE_EXTERNAL"] = "TABLE_FEATURE_STORE_EXTERNAL";
+    SecurableKind["TABLE_STREAMING_LIVE_TABLE"] = "TABLE_STREAMING_LIVE_TABLE";
+    SecurableKind["TABLE_SYSTEM"] = "TABLE_SYSTEM";
+    SecurableKind["TABLE_SYSTEM_DELTASHARING"] = "TABLE_SYSTEM_DELTASHARING";
+    SecurableKind["TABLE_MATERIALIZED_VIEW"] = "TABLE_MATERIALIZED_VIEW";
+    SecurableKind["TABLE_INTERNAL"] = "TABLE_INTERNAL";
+    SecurableKind["TABLE_FOREIGN_BIGQUERY"] = "TABLE_FOREIGN_BIGQUERY";
+    SecurableKind["TABLE_FOREIGN_MYSQL"] = "TABLE_FOREIGN_MYSQL";
+    SecurableKind["TABLE_FOREIGN_ORACLE"] = "TABLE_FOREIGN_ORACLE";
+    SecurableKind["TABLE_FOREIGN_POSTGRESQL"] = "TABLE_FOREIGN_POSTGRESQL";
+    SecurableKind["TABLE_FOREIGN_SQLDW"] = "TABLE_FOREIGN_SQLDW";
+    SecurableKind["TABLE_FOREIGN_REDSHIFT"] = "TABLE_FOREIGN_REDSHIFT";
+    SecurableKind["TABLE_FOREIGN_SNOWFLAKE"] = "TABLE_FOREIGN_SNOWFLAKE";
+    SecurableKind["TABLE_FOREIGN_SQLSERVER"] = "TABLE_FOREIGN_SQLSERVER";
+    SecurableKind["TABLE_FOREIGN_SALESFORCE"] = "TABLE_FOREIGN_SALESFORCE";
+    SecurableKind["TABLE_FOREIGN_SALESFORCE_DATA_CLOUD"] = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD";
+    SecurableKind["TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING"] = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING";
+    SecurableKind["TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING_VIEW"] = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING_VIEW";
+    SecurableKind["TABLE_FOREIGN_TERADATA"] = "TABLE_FOREIGN_TERADATA";
+    SecurableKind["TABLE_FOREIGN_NETSUITE"] = "TABLE_FOREIGN_NETSUITE";
+    SecurableKind["TABLE_FOREIGN_DATABRICKS"] = "TABLE_FOREIGN_DATABRICKS";
+    SecurableKind["TABLE_FOREIGN_WORKDAY_RAAS"] = "TABLE_FOREIGN_WORKDAY_RAAS";
+    /** Deprecated in favor of more specific types below */
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE"] = "TABLE_FOREIGN_HIVE_METASTORE";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_MANAGED"] = "TABLE_FOREIGN_HIVE_METASTORE_MANAGED";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_DBFS_MANAGED"] = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_MANAGED";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_EXTERNAL"] = "TABLE_FOREIGN_HIVE_METASTORE_EXTERNAL";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_DBFS_EXTERNAL"] = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_EXTERNAL";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_VIEW"] = "TABLE_FOREIGN_HIVE_METASTORE_VIEW";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_DBFS_VIEW"] = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_VIEW";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_MANAGED"] = "TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_MANAGED";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_MANAGED"] = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_MANAGED";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_EXTERNAL"] = "TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_EXTERNAL";
+    SecurableKind["TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_EXTERNAL"] = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_EXTERNAL";
+    SecurableKind["TABLE_FOREIGN_MONGODB"] = "TABLE_FOREIGN_MONGODB";
+    SecurableKind["TABLE_DELTA_UNIFORM_HUDI_EXTERNAL"] = "TABLE_DELTA_UNIFORM_HUDI_EXTERNAL";
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL"] = "TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL";
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_EXTERNAL"] = "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_EXTERNAL";
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_MANAGED"] = "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_MANAGED";
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_SNOWFLAKE"] = "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_SNOWFLAKE";
+    /**
+     * The above uniform securableKinds come from different data sources,
+     * each creating a foreign catalog in Databricks with its own capabilities.
+     * UC uses these attributes to interact with remote connections.
+     * For shared foreign iceberg tables, all are under the Delta Sharing catalog
+     * with the same capabilities, so the recipient UC does not need to connect
+     * to the remote source.
+     */
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_DELTASHARING"] = "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_DELTASHARING";
+    /**
+     * This is the delta sharing version of TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL.
+     * Unlike the above foreign iceberg kinds which originate from external catalogs,
+     * this represents an external uniform iceberg table shared via Delta Sharing.
+     */
+    SecurableKind["TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL_DELTASHARING"] = "TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL_DELTASHARING";
+    /** These represent 2 variations of Managed Iceberg tables. See ManagedIcebergTableUtils.scala for more details. */
+    SecurableKind["TABLE_ICEBERG_UNIFORM_MANAGED"] = "TABLE_ICEBERG_UNIFORM_MANAGED";
+    SecurableKind["TABLE_DELTA_ICEBERG_MANAGED"] = "TABLE_DELTA_ICEBERG_MANAGED";
+    SecurableKind["TABLE_ONLINE_VECTOR_INDEX_REPLICA"] = "TABLE_ONLINE_VECTOR_INDEX_REPLICA";
+    SecurableKind["TABLE_ONLINE_VECTOR_INDEX_DIRECT"] = "TABLE_ONLINE_VECTOR_INDEX_DIRECT";
+    SecurableKind["TABLE_ONLINE_VIEW"] = "TABLE_ONLINE_VIEW";
+    SecurableKind["TABLE_DB_STORAGE"] = "TABLE_DB_STORAGE";
+    SecurableKind["TABLE_MANAGED_POSTGRESQL"] = "TABLE_MANAGED_POSTGRESQL";
+})(SecurableKind || (SecurableKind = {}));
+/** The type of Unity Catalog securable. */
+export var SecurableType;
+(function (SecurableType) {
+    SecurableType["CATALOG"] = "CATALOG";
+    SecurableType["SCHEMA"] = "SCHEMA";
+    SecurableType["TABLE"] = "TABLE";
+    SecurableType["STORAGE_CREDENTIAL"] = "STORAGE_CREDENTIAL";
+    SecurableType["EXTERNAL_LOCATION"] = "EXTERNAL_LOCATION";
+    SecurableType["FUNCTION"] = "FUNCTION";
+    SecurableType["SHARE"] = "SHARE";
+    SecurableType["PROVIDER"] = "PROVIDER";
+    SecurableType["RECIPIENT"] = "RECIPIENT";
+    SecurableType["CLEAN_ROOM"] = "CLEAN_ROOM";
+    SecurableType["METASTORE"] = "METASTORE";
+    SecurableType["PIPELINE"] = "PIPELINE";
+    SecurableType["VOLUME"] = "VOLUME";
+    SecurableType["CONNECTION"] = "CONNECTION";
+    SecurableType["CREDENTIAL"] = "CREDENTIAL";
+    SecurableType["EXTERNAL_METADATA"] = "EXTERNAL_METADATA";
+    /** TODO: [UC-2980] Staging tables aren't full-fleged securables yet. */
+    SecurableType["STAGING_TABLE"] = "STAGING_TABLE";
+})(SecurableType || (SecurableType = {}));
+export var SseEncryptionAlgorithm;
+(function (SseEncryptionAlgorithm) {
+    SseEncryptionAlgorithm["SSE_ENCRYPTION_ALGORITHM_UNSPECIFIED"] = "SSE_ENCRYPTION_ALGORITHM_UNSPECIFIED";
+    SseEncryptionAlgorithm["AWS_SSE_S3"] = "AWS_SSE_S3";
+    SseEncryptionAlgorithm["AWS_SSE_KMS"] = "AWS_SSE_KMS";
+})(SseEncryptionAlgorithm || (SseEncryptionAlgorithm = {}));
+export var TableType;
+(function (TableType) {
+    TableType["MANAGED"] = "MANAGED";
+    TableType["EXTERNAL"] = "EXTERNAL";
+    TableType["VIEW"] = "VIEW";
+    TableType["MATERIALIZED_VIEW"] = "MATERIALIZED_VIEW";
+    TableType["STREAMING_TABLE"] = "STREAMING_TABLE";
+    TableType["MANAGED_SHALLOW_CLONE"] = "MANAGED_SHALLOW_CLONE";
+    TableType["FOREIGN"] = "FOREIGN";
+    TableType["EXTERNAL_SHALLOW_CLONE"] = "EXTERNAL_SHALLOW_CLONE";
+    TableType["METRIC_VIEW"] = "METRIC_VIEW";
+})(TableType || (TableType = {}));
+/**
+ * During the OAuth flow, specifies which stage the option should be displayed in the UI.
+ * OAUTH_STAGE_UNSPECIFIED is the default value for options unrelated to the OAuth flow.
+ * BEFORE_AUTHORIZATION_CODE corresponds to options necessary to initiate the OAuth process.
+ * BEFORE_ACCESS_TOKEN corresponds to options that are necessary to create a foreign connection,
+ * but that should be displayed after the authorization code has already been received.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var OptionSpec_OauthStage;
+(function (OptionSpec_OauthStage) {
+    OptionSpec_OauthStage["OAUTH_STAGE_UNSPECIFIED"] = "OAUTH_STAGE_UNSPECIFIED";
+    OptionSpec_OauthStage["BEFORE_AUTHORIZATION_CODE"] = "BEFORE_AUTHORIZATION_CODE";
+    OptionSpec_OauthStage["BEFORE_ACCESS_TOKEN"] = "BEFORE_ACCESS_TOKEN";
+})(OptionSpec_OauthStage || (OptionSpec_OauthStage = {}));
+/**
+ * Type of the option, we purposely follow JavaScript types so that
+ * the UI can map the options to JS types.
+ * https://www.w3schools.com/js/js_datatypes.asp
+ * Enum is a special case that it's just string with selections.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var OptionSpec_OptionType;
+(function (OptionSpec_OptionType) {
+    OptionSpec_OptionType["OPTION_TYPE_UNSPECIFIED"] = "OPTION_TYPE_UNSPECIFIED";
+    OptionSpec_OptionType["OPTION_BOOLEAN"] = "OPTION_BOOLEAN";
+    OptionSpec_OptionType["OPTION_NUMBER"] = "OPTION_NUMBER";
+    OptionSpec_OptionType["OPTION_BIGINT"] = "OPTION_BIGINT";
+    OptionSpec_OptionType["OPTION_STRING"] = "OPTION_STRING";
+    OptionSpec_OptionType["OPTION_ENUM"] = "OPTION_ENUM";
+    OptionSpec_OptionType["OPTION_SERVICE_CREDENTIAL"] = "OPTION_SERVICE_CREDENTIAL";
+    OptionSpec_OptionType["OPTION_MULTILINE_STRING"] = "OPTION_MULTILINE_STRING";
+})(OptionSpec_OptionType || (OptionSpec_OptionType = {}));
+export const unmarshalColumnInfoSchema = z
+    .object({
+    name: z.string().optional(),
+    type_text: z.string().optional(),
+    type_name: z.enum(ColumnTypeName).optional(),
+    position: z.number().optional(),
+    type_precision: z.number().optional(),
+    type_scale: z.number().optional(),
+    type_interval_type: z.string().optional(),
+    type_json: z.string().optional(),
+    comment: z.string().optional(),
+    nullable: z.boolean().optional(),
+    partition_index: z.number().optional(),
+    mask: z.lazy(() => unmarshalColumnMaskSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    typeText: d.type_text,
+    typeName: d.type_name,
+    position: d.position,
+    typePrecision: d.type_precision,
+    typeScale: d.type_scale,
+    typeIntervalType: d.type_interval_type,
+    typeJson: d.type_json,
+    comment: d.comment,
+    nullable: d.nullable,
+    partitionIndex: d.partition_index,
+    mask: d.mask,
+}));
+export const unmarshalColumnMaskSchema = z
+    .object({
+    function_name: z.string().optional(),
+    using_column_names: z.array(z.string()).optional(),
+    using_arguments: z
+        .array(z.lazy(() => unmarshalPolicyFunctionArgumentSchema))
+        .optional(),
+})
+    .transform(d => ({
+    functionName: d.function_name,
+    usingColumnNames: d.using_column_names,
+    usingArguments: d.using_arguments,
+}));
+export const unmarshalConnectionDependencySchema = z
+    .object({
+    connection_name: z.string().optional(),
+})
+    .transform(d => ({
+    connectionName: d.connection_name,
+}));
+export const unmarshalCredentialDependencySchema = z
+    .object({
+    credential_name: z.string().optional(),
+})
+    .transform(d => ({
+    credentialName: d.credential_name,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalDeleteTableConstraintRequest_ResponseSchema = z.object({});
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalDeleteTableRequest_ResponseSchema = z.object({});
+export const unmarshalDeltaRuntimePropertiesKvPairsSchema = z
+    .object({
+    delta_runtime_properties: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    deltaRuntimeProperties: d.delta_runtime_properties,
+}));
+export const unmarshalDependencySchema = z
+    .object({
+    table: z.lazy(() => unmarshalTableDependencySchema).optional(),
+    function: z.lazy(() => unmarshalFunctionDependencySchema).optional(),
+    connection: z.lazy(() => unmarshalConnectionDependencySchema).optional(),
+    credential: z.lazy(() => unmarshalCredentialDependencySchema).optional(),
+})
+    .transform(d => ({
+    value: d.table !== undefined
+        ? { $case: 'table', table: d.table }
+        : d.function !== undefined
+            ? { $case: 'function', function: d.function }
+            : d.connection !== undefined
+                ? { $case: 'connection', connection: d.connection }
+                : d.credential !== undefined
+                    ? { $case: 'credential', credential: d.credential }
+                    : undefined,
+}));
+export const unmarshalDependencyListSchema = z
+    .object({
+    dependencies: z.array(z.lazy(() => unmarshalDependencySchema)).optional(),
+})
+    .transform(d => ({
+    dependencies: d.dependencies,
+}));
+export const unmarshalEffectivePredictiveOptimizationFlagSchema = z
+    .object({
+    value: z.string().optional(),
+    inherited_from_type: z.string().optional(),
+    inherited_from_name: z.string().optional(),
+})
+    .transform(d => ({
+    value: d.value,
+    inheritedFromType: d.inherited_from_type,
+    inheritedFromName: d.inherited_from_name,
+}));
+export const unmarshalEncryptionDetailsSchema = z
+    .object({
+    sse_encryption_details: z
+        .lazy(() => unmarshalSseEncryptionDetailsSchema)
+        .optional(),
+})
+    .transform(d => ({
+    encryptionDetailsType: d.sse_encryption_details !== undefined
+        ? {
+            $case: 'sseEncryptionDetails',
+            sseEncryptionDetails: d.sse_encryption_details,
+        }
+        : undefined,
+}));
+export const unmarshalForeignKeyConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+    child_columns: z.array(z.string()).optional(),
+    parent_table: z.string().optional(),
+    parent_columns: z.array(z.string()).optional(),
+    rely: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    childColumns: d.child_columns,
+    parentTable: d.parent_table,
+    parentColumns: d.parent_columns,
+    rely: d.rely,
+}));
+export const unmarshalFunctionDependencySchema = z
+    .object({
+    function_full_name: z.string().optional(),
+})
+    .transform(d => ({
+    functionFullName: d.function_full_name,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalListTableSummariesRequest_ResponseSchema = z
+    .object({
+    tables: z.array(z.lazy(() => unmarshalTableSummarySchema)).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    tables: d.tables,
+    nextPageToken: d.next_page_token,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalListTablesRequest_ResponseSchema = z
+    .object({
+    tables: z.array(z.lazy(() => unmarshalTableInfoSchema)).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    tables: d.tables,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalNamedTableConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const unmarshalOptionSpecSchema = z
+    .object({
+    name: z.string().optional(),
+    type: z.enum(OptionSpec_OptionType).optional(),
+    default_value: z.string().optional(),
+    allowed_values: z.array(z.string()).optional(),
+    hint: z.string().optional(),
+    description: z.string().optional(),
+    is_required: z.boolean().optional(),
+    is_secret: z.boolean().optional(),
+    is_hidden: z.boolean().optional(),
+    is_updatable: z.boolean().optional(),
+    oauth_stage: z.enum(OptionSpec_OauthStage).optional(),
+    is_loggable: z.boolean().optional(),
+    is_creatable: z.boolean().optional(),
+    is_copiable: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    type: d.type,
+    defaultValue: d.default_value,
+    allowedValues: d.allowed_values,
+    hint: d.hint,
+    description: d.description,
+    isRequired: d.is_required,
+    isSecret: d.is_secret,
+    isHidden: d.is_hidden,
+    isUpdatable: d.is_updatable,
+    oauthStage: d.oauth_stage,
+    isLoggable: d.is_loggable,
+    isCreatable: d.is_creatable,
+    isCopiable: d.is_copiable,
+}));
+export const unmarshalPolicyFunctionArgumentSchema = z
+    .object({
+    column: z.string().optional(),
+    constant: z.string().optional(),
+})
+    .transform(d => ({
+    arg: d.column !== undefined
+        ? { $case: 'column', column: d.column }
+        : d.constant !== undefined
+            ? { $case: 'constant', constant: d.constant }
+            : undefined,
+}));
+export const unmarshalPrimaryKeyConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+    child_columns: z.array(z.string()).optional(),
+    timeseries_columns: z.array(z.string()).optional(),
+    rely: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    childColumns: d.child_columns,
+    timeseriesColumns: d.timeseries_columns,
+    rely: d.rely,
+}));
+export const unmarshalRowFilterSchema = z
+    .object({
+    function_name: z.string().optional(),
+    input_column_names: z.array(z.string()).optional(),
+    input_arguments: z
+        .array(z.lazy(() => unmarshalPolicyFunctionArgumentSchema))
+        .optional(),
+})
+    .transform(d => ({
+    functionName: d.function_name,
+    inputColumnNames: d.input_column_names,
+    inputArguments: d.input_arguments,
+}));
+export const unmarshalSecurableKindManifestSchema = z
+    .object({
+    securable_type: z.enum(SecurableType).optional(),
+    securable_kind: z.enum(SecurableKind).optional(),
+    assignable_privileges: z.array(z.string()).optional(),
+    options: z.array(z.lazy(() => unmarshalOptionSpecSchema)).optional(),
+    capabilities: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    securableType: d.securable_type,
+    securableKind: d.securable_kind,
+    assignablePrivileges: d.assignable_privileges,
+    options: d.options,
+    capabilities: d.capabilities,
+}));
+export const unmarshalSseEncryptionDetailsSchema = z
+    .object({
+    algorithm: z.enum(SseEncryptionAlgorithm).optional(),
+    aws_kms_key_arn: z.string().optional(),
+})
+    .transform(d => ({
+    algorithm: d.algorithm,
+    awsKmsKeyArn: d.aws_kms_key_arn,
+}));
+export const unmarshalTableConstraintSchema = z
+    .object({
+    primary_key_constraint: z
+        .lazy(() => unmarshalPrimaryKeyConstraintSchema)
+        .optional(),
+    foreign_key_constraint: z
+        .lazy(() => unmarshalForeignKeyConstraintSchema)
+        .optional(),
+    named_table_constraint: z
+        .lazy(() => unmarshalNamedTableConstraintSchema)
+        .optional(),
+})
+    .transform(d => ({
+    constraint: d.primary_key_constraint !== undefined
+        ? {
+            $case: 'primaryKeyConstraint',
+            primaryKeyConstraint: d.primary_key_constraint,
+        }
+        : d.foreign_key_constraint !== undefined
+            ? {
+                $case: 'foreignKeyConstraint',
+                foreignKeyConstraint: d.foreign_key_constraint,
+            }
+            : d.named_table_constraint !== undefined
+                ? {
+                    $case: 'namedTableConstraint',
+                    namedTableConstraint: d.named_table_constraint,
+                }
+                : undefined,
+}));
+export const unmarshalTableDependencySchema = z
+    .object({
+    table_full_name: z.string().optional(),
+})
+    .transform(d => ({
+    tableFullName: d.table_full_name,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalTableExistsRequest_ResponseSchema = z
+    .object({
+    table_exists: z.boolean().optional(),
+})
+    .transform(d => ({
+    tableExists: d.table_exists,
+}));
+export const unmarshalTableInfoSchema = z
+    .object({
+    name: z.string().optional(),
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    table_type: z.enum(TableType).optional(),
+    data_source_format: z.enum(DataSourceFormat).optional(),
+    storage_location: z.string().optional(),
+    view_definition: z.string().optional(),
+    view_dependencies: z.lazy(() => unmarshalDependencyListSchema).optional(),
+    sql_path: z.string().optional(),
+    owner: z.string().optional(),
+    comment: z.string().optional(),
+    storage_credential_name: z.string().optional(),
+    table_constraints: z
+        .array(z.lazy(() => unmarshalTableConstraintSchema))
+        .optional(),
+    row_filter: z.lazy(() => unmarshalRowFilterSchema).optional(),
+    pipeline_id: z.string().optional(),
+    enable_predictive_optimization: z.string().optional(),
+    metastore_id: z.string().optional(),
+    full_name: z.string().optional(),
+    data_access_configuration_id: z.string().optional(),
+    created_at: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    created_by: z.string().optional(),
+    updated_at: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    updated_by: z.string().optional(),
+    table_id: z.string().optional(),
+    delta_runtime_properties_kvpairs: z
+        .lazy(() => unmarshalDeltaRuntimePropertiesKvPairsSchema)
+        .optional(),
+    deleted_at: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    effective_predictive_optimization_flag: z
+        .lazy(() => unmarshalEffectivePredictiveOptimizationFlagSchema)
+        .optional(),
+    access_point: z.string().optional(),
+    browse_only: z.boolean().optional(),
+    encryption_details: z
+        .lazy(() => unmarshalEncryptionDetailsSchema)
+        .optional(),
+    securable_kind_manifest: z
+        .lazy(() => unmarshalSecurableKindManifestSchema)
+        .optional(),
+    columns: z.array(z.lazy(() => unmarshalColumnInfoSchema)).optional(),
+    properties: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    tableType: d.table_type,
+    dataSourceFormat: d.data_source_format,
+    storageLocation: d.storage_location,
+    viewDefinition: d.view_definition,
+    viewDependencies: d.view_dependencies,
+    sqlPath: d.sql_path,
+    owner: d.owner,
+    comment: d.comment,
+    storageCredentialName: d.storage_credential_name,
+    tableConstraints: d.table_constraints,
+    rowFilter: d.row_filter,
+    pipelineId: d.pipeline_id,
+    enablePredictiveOptimization: d.enable_predictive_optimization,
+    metastoreId: d.metastore_id,
+    fullName: d.full_name,
+    dataAccessConfigurationId: d.data_access_configuration_id,
+    createdAt: d.created_at,
+    createdBy: d.created_by,
+    updatedAt: d.updated_at,
+    updatedBy: d.updated_by,
+    tableId: d.table_id,
+    deltaRuntimePropertiesKvpairs: d.delta_runtime_properties_kvpairs,
+    deletedAt: d.deleted_at,
+    effectivePredictiveOptimizationFlag: d.effective_predictive_optimization_flag,
+    accessPoint: d.access_point,
+    browseOnly: d.browse_only,
+    encryptionDetails: d.encryption_details,
+    securableKindManifest: d.securable_kind_manifest,
+    columns: d.columns,
+    properties: d.properties,
+}));
+export const unmarshalTableSummarySchema = z
+    .object({
+    full_name: z.string().optional(),
+    table_type: z.enum(TableType).optional(),
+    securable_kind_manifest: z
+        .lazy(() => unmarshalSecurableKindManifestSchema)
+        .optional(),
+})
+    .transform(d => ({
+    fullName: d.full_name,
+    tableType: d.table_type,
+    securableKindManifest: d.securable_kind_manifest,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalUpdateTableRequest_ResponseSchema = z.object({});
+export const marshalColumnInfoSchema = z
+    .object({
+    name: z.string().optional(),
+    typeText: z.string().optional(),
+    typeName: z.enum(ColumnTypeName).optional(),
+    position: z.number().optional(),
+    typePrecision: z.number().optional(),
+    typeScale: z.number().optional(),
+    typeIntervalType: z.string().optional(),
+    typeJson: z.string().optional(),
+    comment: z.string().optional(),
+    nullable: z.boolean().optional(),
+    partitionIndex: z.number().optional(),
+    mask: z.lazy(() => marshalColumnMaskSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    type_text: d.typeText,
+    type_name: d.typeName,
+    position: d.position,
+    type_precision: d.typePrecision,
+    type_scale: d.typeScale,
+    type_interval_type: d.typeIntervalType,
+    type_json: d.typeJson,
+    comment: d.comment,
+    nullable: d.nullable,
+    partition_index: d.partitionIndex,
+    mask: d.mask,
+}));
+export const marshalColumnMaskSchema = z
+    .object({
+    functionName: z.string().optional(),
+    usingColumnNames: z.array(z.string()).optional(),
+    usingArguments: z
+        .array(z.lazy(() => marshalPolicyFunctionArgumentSchema))
+        .optional(),
+})
+    .transform(d => ({
+    function_name: d.functionName,
+    using_column_names: d.usingColumnNames,
+    using_arguments: d.usingArguments,
+}));
+export const marshalConnectionDependencySchema = z
+    .object({
+    connectionName: z.string().optional(),
+})
+    .transform(d => ({
+    connection_name: d.connectionName,
+}));
+export const marshalCreateTableConstraintRequestSchema = z
+    .object({
+    fullNameArg: z.string().optional(),
+    constraint: z.lazy(() => marshalTableConstraintSchema).optional(),
+})
+    .transform(d => ({
+    full_name_arg: d.fullNameArg,
+    constraint: d.constraint,
+}));
+export const marshalCreateTableRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableType: z.enum(TableType).optional(),
+    dataSourceFormat: z.enum(DataSourceFormat).optional(),
+    storageLocation: z.string().optional(),
+    viewDefinition: z.string().optional(),
+    viewDependencies: z.lazy(() => marshalDependencyListSchema).optional(),
+    sqlPath: z.string().optional(),
+    owner: z.string().optional(),
+    comment: z.string().optional(),
+    storageCredentialName: z.string().optional(),
+    tableConstraints: z
+        .array(z.lazy(() => marshalTableConstraintSchema))
+        .optional(),
+    rowFilter: z.lazy(() => marshalRowFilterSchema).optional(),
+    pipelineId: z.string().optional(),
+    enablePredictiveOptimization: z.string().optional(),
+    metastoreId: z.string().optional(),
+    fullName: z.string().optional(),
+    dataAccessConfigurationId: z.string().optional(),
+    createdAt: z.bigint().optional(),
+    createdBy: z.string().optional(),
+    updatedAt: z.bigint().optional(),
+    updatedBy: z.string().optional(),
+    tableId: z.string().optional(),
+    deltaRuntimePropertiesKvpairs: z
+        .lazy(() => marshalDeltaRuntimePropertiesKvPairsSchema)
+        .optional(),
+    deletedAt: z.bigint().optional(),
+    effectivePredictiveOptimizationFlag: z
+        .lazy(() => marshalEffectivePredictiveOptimizationFlagSchema)
+        .optional(),
+    accessPoint: z.string().optional(),
+    browseOnly: z.boolean().optional(),
+    encryptionDetails: z.lazy(() => marshalEncryptionDetailsSchema).optional(),
+    securableKindManifest: z
+        .lazy(() => marshalSecurableKindManifestSchema)
+        .optional(),
+    columns: z.array(z.lazy(() => marshalColumnInfoSchema)).optional(),
+    properties: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_type: d.tableType,
+    data_source_format: d.dataSourceFormat,
+    storage_location: d.storageLocation,
+    view_definition: d.viewDefinition,
+    view_dependencies: d.viewDependencies,
+    sql_path: d.sqlPath,
+    owner: d.owner,
+    comment: d.comment,
+    storage_credential_name: d.storageCredentialName,
+    table_constraints: d.tableConstraints,
+    row_filter: d.rowFilter,
+    pipeline_id: d.pipelineId,
+    enable_predictive_optimization: d.enablePredictiveOptimization,
+    metastore_id: d.metastoreId,
+    full_name: d.fullName,
+    data_access_configuration_id: d.dataAccessConfigurationId,
+    created_at: d.createdAt,
+    created_by: d.createdBy,
+    updated_at: d.updatedAt,
+    updated_by: d.updatedBy,
+    table_id: d.tableId,
+    delta_runtime_properties_kvpairs: d.deltaRuntimePropertiesKvpairs,
+    deleted_at: d.deletedAt,
+    effective_predictive_optimization_flag: d.effectivePredictiveOptimizationFlag,
+    access_point: d.accessPoint,
+    browse_only: d.browseOnly,
+    encryption_details: d.encryptionDetails,
+    securable_kind_manifest: d.securableKindManifest,
+    columns: d.columns,
+    properties: d.properties,
+}));
+export const marshalCredentialDependencySchema = z
+    .object({
+    credentialName: z.string().optional(),
+})
+    .transform(d => ({
+    credential_name: d.credentialName,
+}));
+export const marshalDeltaRuntimePropertiesKvPairsSchema = z
+    .object({
+    deltaRuntimeProperties: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    delta_runtime_properties: d.deltaRuntimeProperties,
+}));
+export const marshalDependencySchema = z
+    .object({
+    value: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('table'),
+            table: z.lazy(() => marshalTableDependencySchema),
+        }),
+        z.object({
+            $case: z.literal('function'),
+            function: z.lazy(() => marshalFunctionDependencySchema),
+        }),
+        z.object({
+            $case: z.literal('connection'),
+            connection: z.lazy(() => marshalConnectionDependencySchema),
+        }),
+        z.object({
+            $case: z.literal('credential'),
+            credential: z.lazy(() => marshalCredentialDependencySchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.value?.$case === 'table' && { table: d.value.table }),
+    ...(d.value?.$case === 'function' && { function: d.value.function }),
+    ...(d.value?.$case === 'connection' && { connection: d.value.connection }),
+    ...(d.value?.$case === 'credential' && { credential: d.value.credential }),
+}));
+export const marshalDependencyListSchema = z
+    .object({
+    dependencies: z.array(z.lazy(() => marshalDependencySchema)).optional(),
+})
+    .transform(d => ({
+    dependencies: d.dependencies,
+}));
+export const marshalEffectivePredictiveOptimizationFlagSchema = z
+    .object({
+    value: z.string().optional(),
+    inheritedFromType: z.string().optional(),
+    inheritedFromName: z.string().optional(),
+})
+    .transform(d => ({
+    value: d.value,
+    inherited_from_type: d.inheritedFromType,
+    inherited_from_name: d.inheritedFromName,
+}));
+export const marshalEncryptionDetailsSchema = z
+    .object({
+    encryptionDetailsType: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('sseEncryptionDetails'),
+            sseEncryptionDetails: z.lazy(() => marshalSseEncryptionDetailsSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.encryptionDetailsType?.$case === 'sseEncryptionDetails' && {
+        sse_encryption_details: d.encryptionDetailsType.sseEncryptionDetails,
+    }),
+}));
+export const marshalForeignKeyConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+    childColumns: z.array(z.string()).optional(),
+    parentTable: z.string().optional(),
+    parentColumns: z.array(z.string()).optional(),
+    rely: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    child_columns: d.childColumns,
+    parent_table: d.parentTable,
+    parent_columns: d.parentColumns,
+    rely: d.rely,
+}));
+export const marshalFunctionDependencySchema = z
+    .object({
+    functionFullName: z.string().optional(),
+})
+    .transform(d => ({
+    function_full_name: d.functionFullName,
+}));
+export const marshalNamedTableConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const marshalOptionSpecSchema = z
+    .object({
+    name: z.string().optional(),
+    type: z.enum(OptionSpec_OptionType).optional(),
+    defaultValue: z.string().optional(),
+    allowedValues: z.array(z.string()).optional(),
+    hint: z.string().optional(),
+    description: z.string().optional(),
+    isRequired: z.boolean().optional(),
+    isSecret: z.boolean().optional(),
+    isHidden: z.boolean().optional(),
+    isUpdatable: z.boolean().optional(),
+    oauthStage: z.enum(OptionSpec_OauthStage).optional(),
+    isLoggable: z.boolean().optional(),
+    isCreatable: z.boolean().optional(),
+    isCopiable: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    type: d.type,
+    default_value: d.defaultValue,
+    allowed_values: d.allowedValues,
+    hint: d.hint,
+    description: d.description,
+    is_required: d.isRequired,
+    is_secret: d.isSecret,
+    is_hidden: d.isHidden,
+    is_updatable: d.isUpdatable,
+    oauth_stage: d.oauthStage,
+    is_loggable: d.isLoggable,
+    is_creatable: d.isCreatable,
+    is_copiable: d.isCopiable,
+}));
+export const marshalPolicyFunctionArgumentSchema = z
+    .object({
+    arg: z
+        .discriminatedUnion('$case', [
+        z.object({ $case: z.literal('column'), column: z.string() }),
+        z.object({ $case: z.literal('constant'), constant: z.string() }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.arg?.$case === 'column' && { column: d.arg.column }),
+    ...(d.arg?.$case === 'constant' && { constant: d.arg.constant }),
+}));
+export const marshalPrimaryKeyConstraintSchema = z
+    .object({
+    name: z.string().optional(),
+    childColumns: z.array(z.string()).optional(),
+    timeseriesColumns: z.array(z.string()).optional(),
+    rely: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    child_columns: d.childColumns,
+    timeseries_columns: d.timeseriesColumns,
+    rely: d.rely,
+}));
+export const marshalRowFilterSchema = z
+    .object({
+    functionName: z.string().optional(),
+    inputColumnNames: z.array(z.string()).optional(),
+    inputArguments: z
+        .array(z.lazy(() => marshalPolicyFunctionArgumentSchema))
+        .optional(),
+})
+    .transform(d => ({
+    function_name: d.functionName,
+    input_column_names: d.inputColumnNames,
+    input_arguments: d.inputArguments,
+}));
+export const marshalSecurableKindManifestSchema = z
+    .object({
+    securableType: z.enum(SecurableType).optional(),
+    securableKind: z.enum(SecurableKind).optional(),
+    assignablePrivileges: z.array(z.string()).optional(),
+    options: z.array(z.lazy(() => marshalOptionSpecSchema)).optional(),
+    capabilities: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    securable_type: d.securableType,
+    securable_kind: d.securableKind,
+    assignable_privileges: d.assignablePrivileges,
+    options: d.options,
+    capabilities: d.capabilities,
+}));
+export const marshalSseEncryptionDetailsSchema = z
+    .object({
+    algorithm: z.enum(SseEncryptionAlgorithm).optional(),
+    awsKmsKeyArn: z.string().optional(),
+})
+    .transform(d => ({
+    algorithm: d.algorithm,
+    aws_kms_key_arn: d.awsKmsKeyArn,
+}));
+export const marshalTableConstraintSchema = z
+    .object({
+    constraint: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('primaryKeyConstraint'),
+            primaryKeyConstraint: z.lazy(() => marshalPrimaryKeyConstraintSchema),
+        }),
+        z.object({
+            $case: z.literal('foreignKeyConstraint'),
+            foreignKeyConstraint: z.lazy(() => marshalForeignKeyConstraintSchema),
+        }),
+        z.object({
+            $case: z.literal('namedTableConstraint'),
+            namedTableConstraint: z.lazy(() => marshalNamedTableConstraintSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    ...(d.constraint?.$case === 'primaryKeyConstraint' && {
+        primary_key_constraint: d.constraint.primaryKeyConstraint,
+    }),
+    ...(d.constraint?.$case === 'foreignKeyConstraint' && {
+        foreign_key_constraint: d.constraint.foreignKeyConstraint,
+    }),
+    ...(d.constraint?.$case === 'namedTableConstraint' && {
+        named_table_constraint: d.constraint.namedTableConstraint,
+    }),
+}));
+export const marshalTableDependencySchema = z
+    .object({
+    tableFullName: z.string().optional(),
+})
+    .transform(d => ({
+    table_full_name: d.tableFullName,
+}));
+export const marshalUpdateTableRequestSchema = z
+    .object({
+    fullNameArg: z.string().optional(),
+    name: z.string().optional(),
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableType: z.enum(TableType).optional(),
+    dataSourceFormat: z.enum(DataSourceFormat).optional(),
+    storageLocation: z.string().optional(),
+    viewDefinition: z.string().optional(),
+    viewDependencies: z.lazy(() => marshalDependencyListSchema).optional(),
+    sqlPath: z.string().optional(),
+    owner: z.string().optional(),
+    comment: z.string().optional(),
+    storageCredentialName: z.string().optional(),
+    tableConstraints: z
+        .array(z.lazy(() => marshalTableConstraintSchema))
+        .optional(),
+    rowFilter: z.lazy(() => marshalRowFilterSchema).optional(),
+    pipelineId: z.string().optional(),
+    enablePredictiveOptimization: z.string().optional(),
+    metastoreId: z.string().optional(),
+    fullName: z.string().optional(),
+    dataAccessConfigurationId: z.string().optional(),
+    createdAt: z.bigint().optional(),
+    createdBy: z.string().optional(),
+    updatedAt: z.bigint().optional(),
+    updatedBy: z.string().optional(),
+    tableId: z.string().optional(),
+    deltaRuntimePropertiesKvpairs: z
+        .lazy(() => marshalDeltaRuntimePropertiesKvPairsSchema)
+        .optional(),
+    deletedAt: z.bigint().optional(),
+    effectivePredictiveOptimizationFlag: z
+        .lazy(() => marshalEffectivePredictiveOptimizationFlagSchema)
+        .optional(),
+    accessPoint: z.string().optional(),
+    browseOnly: z.boolean().optional(),
+    encryptionDetails: z.lazy(() => marshalEncryptionDetailsSchema).optional(),
+    securableKindManifest: z
+        .lazy(() => marshalSecurableKindManifestSchema)
+        .optional(),
+    columns: z.array(z.lazy(() => marshalColumnInfoSchema)).optional(),
+    properties: z.record(z.string(), z.string()).optional(),
+})
+    .transform(d => ({
+    full_name_arg: d.fullNameArg,
+    name: d.name,
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_type: d.tableType,
+    data_source_format: d.dataSourceFormat,
+    storage_location: d.storageLocation,
+    view_definition: d.viewDefinition,
+    view_dependencies: d.viewDependencies,
+    sql_path: d.sqlPath,
+    owner: d.owner,
+    comment: d.comment,
+    storage_credential_name: d.storageCredentialName,
+    table_constraints: d.tableConstraints,
+    row_filter: d.rowFilter,
+    pipeline_id: d.pipelineId,
+    enable_predictive_optimization: d.enablePredictiveOptimization,
+    metastore_id: d.metastoreId,
+    full_name: d.fullName,
+    data_access_configuration_id: d.dataAccessConfigurationId,
+    created_at: d.createdAt,
+    created_by: d.createdBy,
+    updated_at: d.updatedAt,
+    updated_by: d.updatedBy,
+    table_id: d.tableId,
+    delta_runtime_properties_kvpairs: d.deltaRuntimePropertiesKvpairs,
+    deleted_at: d.deletedAt,
+    effective_predictive_optimization_flag: d.effectivePredictiveOptimizationFlag,
+    access_point: d.accessPoint,
+    browse_only: d.browseOnly,
+    encryption_details: d.encryptionDetails,
+    securable_kind_manifest: d.securableKindManifest,
+    columns: d.columns,
+    properties: d.properties,
+}));
+//# sourceMappingURL=model.js.map