@databricks/sdk-modelserving 0.0.0-dev → 0.1.0-dev.1

package/dist/v1/model.js

@@ -0,0 +1,1424 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+import { z } from 'zod';
+export var Behavior;
+(function (Behavior) {
+    Behavior["BEHAVIOR_UNSPECIFIED"] = "BEHAVIOR_UNSPECIFIED";
+    Behavior["NONE"] = "NONE";
+    Behavior["BLOCK"] = "BLOCK";
+    Behavior["MASK"] = "MASK";
+})(Behavior || (Behavior = {}));
+export var ServedModelDeploymentState;
+(function (ServedModelDeploymentState) {
+    ServedModelDeploymentState["DEPLOYMENT_UNKNOWN"] = "DEPLOYMENT_UNKNOWN";
+    ServedModelDeploymentState["DEPLOYMENT_CREATING"] = "DEPLOYMENT_CREATING";
+    ServedModelDeploymentState["DEPLOYMENT_RECOVERING"] = "DEPLOYMENT_RECOVERING";
+    ServedModelDeploymentState["DEPLOYMENT_READY"] = "DEPLOYMENT_READY";
+    ServedModelDeploymentState["DEPLOYMENT_FAILED"] = "DEPLOYMENT_FAILED";
+    ServedModelDeploymentState["DEPLOYMENT_ABORTED"] = "DEPLOYMENT_ABORTED";
+    ServedModelDeploymentState["DEPLOYMENT_STOPPED"] = "DEPLOYMENT_STOPPED";
+})(ServedModelDeploymentState || (ServedModelDeploymentState = {}));
+export var ServingEndpointDetailedPermissionLevel;
+(function (ServingEndpointDetailedPermissionLevel) {
+    ServingEndpointDetailedPermissionLevel["CAN_MANAGE"] = "CAN_MANAGE";
+    ServingEndpointDetailedPermissionLevel["CAN_QUERY"] = "CAN_QUERY";
+    ServingEndpointDetailedPermissionLevel["CAN_VIEW"] = "CAN_VIEW";
+})(ServingEndpointDetailedPermissionLevel || (ServingEndpointDetailedPermissionLevel = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var ExternalFunctionRequest_HttpMethod;
+(function (ExternalFunctionRequest_HttpMethod) {
+    ExternalFunctionRequest_HttpMethod["HTTP_METHOD_UNSPECIFIED"] = "HTTP_METHOD_UNSPECIFIED";
+    ExternalFunctionRequest_HttpMethod["GET"] = "GET";
+    ExternalFunctionRequest_HttpMethod["POST"] = "POST";
+    ExternalFunctionRequest_HttpMethod["PUT"] = "PUT";
+    ExternalFunctionRequest_HttpMethod["DELETE"] = "DELETE";
+    ExternalFunctionRequest_HttpMethod["PATCH"] = "PATCH";
+})(ExternalFunctionRequest_HttpMethod || (ExternalFunctionRequest_HttpMethod = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var InferenceEndpointState_ConfigUpdateState;
+(function (InferenceEndpointState_ConfigUpdateState) {
+    InferenceEndpointState_ConfigUpdateState["CONFIG_UPDATE_STATE_UNSPECIFIED"] = "CONFIG_UPDATE_STATE_UNSPECIFIED";
+    InferenceEndpointState_ConfigUpdateState["NOT_UPDATING"] = "NOT_UPDATING";
+    InferenceEndpointState_ConfigUpdateState["IN_PROGRESS"] = "IN_PROGRESS";
+    InferenceEndpointState_ConfigUpdateState["UPDATE_FAILED"] = "UPDATE_FAILED";
+    InferenceEndpointState_ConfigUpdateState["UPDATE_CANCELED"] = "UPDATE_CANCELED";
+})(InferenceEndpointState_ConfigUpdateState || (InferenceEndpointState_ConfigUpdateState = {}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var InferenceEndpointState_ReadyState;
+(function (InferenceEndpointState_ReadyState) {
+    InferenceEndpointState_ReadyState["READY_STATE_UNSPECIFIED"] = "READY_STATE_UNSPECIFIED";
+    InferenceEndpointState_ReadyState["READY"] = "READY";
+    InferenceEndpointState_ReadyState["NOT_READY"] = "NOT_READY";
+})(InferenceEndpointState_ReadyState || (InferenceEndpointState_ReadyState = {}));
+export const unmarshalAi21LabsConfigSchema = z
+    .object({
+    ai21labs_api_key: z.string().optional(),
+    ai21labs_api_key_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    ai21labsApiKey: d.ai21labs_api_key,
+    ai21labsApiKeyPlaintext: d.ai21labs_api_key_plaintext,
+}));
+export const unmarshalAiGatewayConfigSchema = z
+    .object({
+    usage_tracking_config: z
+        .lazy(() => unmarshalUsageTrackingConfigSchema)
+        .optional(),
+    inference_table_config: z
+        .lazy(() => unmarshalInferenceTableConfigSchema)
+        .optional(),
+    rate_limits: z
+        .array(z.lazy(() => unmarshalAiGatewayRateLimitSchema))
+        .optional(),
+    guardrails: z.lazy(() => unmarshalAiGuardrailsSchema).optional(),
+    fallback_config: z.lazy(() => unmarshalFallbackConfigSchema).optional(),
+})
+    .transform(d => ({
+    usageTrackingConfig: d.usage_tracking_config,
+    inferenceTableConfig: d.inference_table_config,
+    rateLimits: d.rate_limits,
+    guardrails: d.guardrails,
+    fallbackConfig: d.fallback_config,
+}));
+export const unmarshalAiGatewayRateLimitSchema = z
+    .object({
+    calls: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    key: z.string().optional(),
+    renewal_period: z.string().optional(),
+    principal: z.string().optional(),
+    tokens: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    calls: d.calls,
+    key: d.key,
+    renewalPeriod: d.renewal_period,
+    principal: d.principal,
+    tokens: d.tokens,
+}));
+export const unmarshalAiGuardrailParametersSchema = z
+    .object({
+    safety: z.boolean().optional(),
+    pii: z.lazy(() => unmarshalPiiSettingsSchema).optional(),
+    valid_topics: z.array(z.string()).optional(),
+    invalid_keywords: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    safety: d.safety,
+    pii: d.pii,
+    validTopics: d.valid_topics,
+    invalidKeywords: d.invalid_keywords,
+}));
+export const unmarshalAiGuardrailsSchema = z
+    .object({
+    input: z.lazy(() => unmarshalAiGuardrailParametersSchema).optional(),
+    output: z.lazy(() => unmarshalAiGuardrailParametersSchema).optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    output: d.output,
+}));
+export const unmarshalAmazonBedrockConfigSchema = z
+    .object({
+    aws_region: z.string().optional(),
+    aws_access_key_id: z.string().optional(),
+    aws_secret_access_key: z.string().optional(),
+    bedrock_provider: z.string().optional(),
+    aws_access_key_id_plaintext: z.string().optional(),
+    aws_secret_access_key_plaintext: z.string().optional(),
+    instance_profile_arn: z.string().optional(),
+})
+    .transform(d => ({
+    awsRegion: d.aws_region,
+    awsAccessKeyId: d.aws_access_key_id,
+    awsSecretAccessKey: d.aws_secret_access_key,
+    bedrockProvider: d.bedrock_provider,
+    awsAccessKeyIdPlaintext: d.aws_access_key_id_plaintext,
+    awsSecretAccessKeyPlaintext: d.aws_secret_access_key_plaintext,
+    instanceProfileArn: d.instance_profile_arn,
+}));
+export const unmarshalAnthropicConfigSchema = z
+    .object({
+    anthropic_api_key: z.string().optional(),
+    anthropic_api_key_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    anthropicApiKey: d.anthropic_api_key,
+    anthropicApiKeyPlaintext: d.anthropic_api_key_plaintext,
+}));
+export const unmarshalApiKeyAuthSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+    value_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+    valuePlaintext: d.value_plaintext,
+}));
+export const unmarshalAutoCaptureConfigSchema = z
+    .object({
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    table_name_prefix: z.string().optional(),
+    state: z.lazy(() => unmarshalAutoCaptureStateSchema).optional(),
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    tableNamePrefix: d.table_name_prefix,
+    state: d.state,
+    enabled: d.enabled,
+}));
+export const unmarshalAutoCaptureStateSchema = z
+    .object({
+    payload_table: z.lazy(() => unmarshalPayloadTableSchema).optional(),
+})
+    .transform(d => ({
+    payloadTable: d.payload_table,
+}));
+export const unmarshalBearerTokenAuthSchema = z
+    .object({
+    token: z.string().optional(),
+    token_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    token: d.token,
+    tokenPlaintext: d.token_plaintext,
+}));
+export const unmarshalCohereConfigSchema = z
+    .object({
+    cohere_api_key: z.string().optional(),
+    cohere_api_key_plaintext: z.string().optional(),
+    cohere_api_base: z.string().optional(),
+})
+    .transform(d => ({
+    cohereApiKey: d.cohere_api_key,
+    cohereApiKeyPlaintext: d.cohere_api_key_plaintext,
+    cohereApiBase: d.cohere_api_base,
+}));
+export const unmarshalCustomProviderConfigSchema = z
+    .object({
+    custom_provider_url: z.string().optional(),
+    bearer_token_auth: z
+        .lazy(() => unmarshalBearerTokenAuthSchema)
+        .optional(),
+    api_key_auth: z.lazy(() => unmarshalApiKeyAuthSchema).optional(),
+})
+    .transform(d => ({
+    customProviderUrl: d.custom_provider_url,
+    bearerTokenAuth: d.bearer_token_auth,
+    apiKeyAuth: d.api_key_auth,
+}));
+export const unmarshalDataPlaneInfoSchema = z
+    .object({
+    endpoint_url: z.string().optional(),
+    authorization_details: z.string().optional(),
+})
+    .transform(d => ({
+    endpointUrl: d.endpoint_url,
+    authorizationDetails: d.authorization_details,
+}));
+export const unmarshalDatabricksModelServingConfigSchema = z
+    .object({
+    databricks_api_token: z.string().optional(),
+    databricks_workspace_url: z.string().optional(),
+    databricks_api_token_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    databricksApiToken: d.databricks_api_token,
+    databricksWorkspaceUrl: d.databricks_workspace_url,
+    databricksApiTokenPlaintext: d.databricks_api_token_plaintext,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalDeleteInferenceEndpointRequest_ResponseSchema = z.object({});
+export const unmarshalEmailNotificationsSchema = z
+    .object({
+    on_update_success: z.array(z.string()).optional(),
+    on_update_failure: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    onUpdateSuccess: d.on_update_success,
+    onUpdateFailure: d.on_update_failure,
+}));
+export const unmarshalEndpointCoreConfigOutputSchema = z
+    .object({
+    config_version: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    served_entities: z
+        .array(z.lazy(() => unmarshalServedModelSchema))
+        .optional(),
+    served_models: z
+        .array(z.lazy(() => unmarshalServedModelSchema))
+        .optional(),
+    traffic_config: z.lazy(() => unmarshalTrafficConfigSchema).optional(),
+    auto_capture_config: z
+        .lazy(() => unmarshalAutoCaptureConfigSchema)
+        .optional(),
+})
+    .transform(d => ({
+    configVersion: d.config_version,
+    servedEntities: d.served_entities,
+    servedModels: d.served_models,
+    trafficConfig: d.traffic_config,
+    autoCaptureConfig: d.auto_capture_config,
+}));
+export const unmarshalEndpointCoreConfigSummarySchema = z
+    .object({
+    served_entities: z
+        .array(z.lazy(() => unmarshalServedModelLiteSchema))
+        .optional(),
+    served_models: z
+        .array(z.lazy(() => unmarshalServedModelLiteSchema))
+        .optional(),
+})
+    .transform(d => ({
+    servedEntities: d.served_entities,
+    servedModels: d.served_models,
+}));
+export const unmarshalEndpointTagSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const unmarshalExternalModelSchema = z
+    .object({
+    provider: z.string().optional(),
+    name: z.string().optional(),
+    task: z.string().optional(),
+    ai21labs_config: z.lazy(() => unmarshalAi21LabsConfigSchema).optional(),
+    anthropic_config: z.lazy(() => unmarshalAnthropicConfigSchema).optional(),
+    amazon_bedrock_config: z
+        .lazy(() => unmarshalAmazonBedrockConfigSchema)
+        .optional(),
+    cohere_config: z.lazy(() => unmarshalCohereConfigSchema).optional(),
+    google_cloud_vertex_ai_config: z
+        .lazy(() => unmarshalGoogleCloudVertexAiConfigSchema)
+        .optional(),
+    databricks_model_serving_config: z
+        .lazy(() => unmarshalDatabricksModelServingConfigSchema)
+        .optional(),
+    openai_config: z.lazy(() => unmarshalOpenAiConfigSchema).optional(),
+    palm_config: z.lazy(() => unmarshalPaLmConfigSchema).optional(),
+    custom_provider_config: z
+        .lazy(() => unmarshalCustomProviderConfigSchema)
+        .optional(),
+})
+    .transform(d => ({
+    provider: d.provider,
+    name: d.name,
+    task: d.task,
+    config: d.ai21labs_config !== undefined
+        ? { $case: 'ai21labsConfig', ai21labsConfig: d.ai21labs_config }
+        : d.anthropic_config !== undefined
+            ? {
+                $case: 'anthropicConfig',
+                anthropicConfig: d.anthropic_config,
+            }
+            : d.amazon_bedrock_config !== undefined
+                ? {
+                    $case: 'amazonBedrockConfig',
+                    amazonBedrockConfig: d.amazon_bedrock_config,
+                }
+                : d.cohere_config !== undefined
+                    ? { $case: 'cohereConfig', cohereConfig: d.cohere_config }
+                    : d.google_cloud_vertex_ai_config !== undefined
+                        ? {
+                            $case: 'googleCloudVertexAiConfig',
+                            googleCloudVertexAiConfig: d.google_cloud_vertex_ai_config,
+                        }
+                        : d.databricks_model_serving_config !== undefined
+                            ? {
+                                $case: 'databricksModelServingConfig',
+                                databricksModelServingConfig: d.databricks_model_serving_config,
+                            }
+                            : d.openai_config !== undefined
+                                ? {
+                                    $case: 'openaiConfig',
+                                    openaiConfig: d.openai_config,
+                                }
+                                : d.palm_config !== undefined
+                                    ? {
+                                        $case: 'palmConfig',
+                                        palmConfig: d.palm_config,
+                                    }
+                                    : d.custom_provider_config !== undefined
+                                        ? {
+                                            $case: 'customProviderConfig',
+                                            customProviderConfig: d.custom_provider_config,
+                                        }
+                                        : undefined,
+}));
+export const unmarshalFallbackConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    enabled: d.enabled,
+}));
+export const unmarshalFoundationModelSchema = z
+    .object({
+    name: z.string().optional(),
+    display_name: z.string().optional(),
+    docs: z.string().optional(),
+    description: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    displayName: d.display_name,
+    docs: d.docs,
+    description: d.description,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalGetServedModelBuildLogsRequest_ResponseSchema = z
+    .object({
+    logs: z.string().optional(),
+})
+    .transform(d => ({
+    logs: d.logs,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalGetServedModelLogsRequest_ResponseSchema = z
+    .object({
+    logs: z.string().optional(),
+})
+    .transform(d => ({
+    logs: d.logs,
+}));
+export const unmarshalGoogleCloudVertexAiConfigSchema = z
+    .object({
+    private_key: z.string().optional(),
+    project_id: z.string().optional(),
+    region: z.string().optional(),
+    private_key_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    privateKey: d.private_key,
+    projectId: d.project_id,
+    region: d.region,
+    privateKeyPlaintext: d.private_key_plaintext,
+}));
+export const unmarshalInferenceEndpointSchema = z
+    .object({
+    name: z.string().optional(),
+    creator: z.string().optional(),
+    creation_timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    last_updated_timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    state: z.lazy(() => unmarshalInferenceEndpointStateSchema).optional(),
+    config: z.lazy(() => unmarshalEndpointCoreConfigSummarySchema).optional(),
+    tags: z.array(z.lazy(() => unmarshalEndpointTagSchema)).optional(),
+    id: z.string().optional(),
+    task: z.string().optional(),
+    ai_gateway: z.lazy(() => unmarshalAiGatewayConfigSchema).optional(),
+    budget_policy_id: z.string().optional(),
+    description: z.string().optional(),
+    usage_policy_id: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    creator: d.creator,
+    creationTimestamp: d.creation_timestamp,
+    lastUpdatedTimestamp: d.last_updated_timestamp,
+    state: d.state,
+    config: d.config,
+    tags: d.tags,
+    id: d.id,
+    task: d.task,
+    aiGateway: d.ai_gateway,
+    budgetPolicyId: d.budget_policy_id,
+    description: d.description,
+    usagePolicyId: d.usage_policy_id,
+}));
+export const unmarshalInferenceEndpointDetailedSchema = z
+    .object({
+    name: z.string().optional(),
+    creator: z.string().optional(),
+    creation_timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    last_updated_timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    state: z.lazy(() => unmarshalInferenceEndpointStateSchema).optional(),
+    config: z.lazy(() => unmarshalEndpointCoreConfigOutputSchema).optional(),
+    pending_config: z.lazy(() => unmarshalPendingConfigSchema).optional(),
+    id: z.string().optional(),
+    permission_level: z
+        .enum(ServingEndpointDetailedPermissionLevel)
+        .optional(),
+    tags: z.array(z.lazy(() => unmarshalEndpointTagSchema)).optional(),
+    task: z.string().optional(),
+    route_optimized: z.boolean().optional(),
+    endpoint_url: z.string().optional(),
+    data_plane_info: z
+        .lazy(() => unmarshalModelDataPlaneInfoSchema)
+        .optional(),
+    ai_gateway: z.lazy(() => unmarshalAiGatewayConfigSchema).optional(),
+    budget_policy_id: z.string().optional(),
+    email_notifications: z
+        .lazy(() => unmarshalEmailNotificationsSchema)
+        .optional(),
+    description: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    creator: d.creator,
+    creationTimestamp: d.creation_timestamp,
+    lastUpdatedTimestamp: d.last_updated_timestamp,
+    state: d.state,
+    config: d.config,
+    pendingConfig: d.pending_config,
+    id: d.id,
+    permissionLevel: d.permission_level,
+    tags: d.tags,
+    task: d.task,
+    routeOptimized: d.route_optimized,
+    endpointUrl: d.endpoint_url,
+    dataPlaneInfo: d.data_plane_info,
+    aiGateway: d.ai_gateway,
+    budgetPolicyId: d.budget_policy_id,
+    emailNotifications: d.email_notifications,
+    description: d.description,
+}));
+export const unmarshalInferenceEndpointStateSchema = z
+    .object({
+    ready: z.enum(InferenceEndpointState_ReadyState).optional(),
+    config_update: z
+        .enum(InferenceEndpointState_ConfigUpdateState)
+        .optional(),
+})
+    .transform(d => ({
+    ready: d.ready,
+    configUpdate: d.config_update,
+}));
+export const unmarshalInferenceTableConfigSchema = z
+    .object({
+    catalog_name: z.string().optional(),
+    schema_name: z.string().optional(),
+    table_name_prefix: z.string().optional(),
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    catalogName: d.catalog_name,
+    schemaName: d.schema_name,
+    tableNamePrefix: d.table_name_prefix,
+    enabled: d.enabled,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalListInferenceEndpointsRequest_ResponseSchema = z
+    .object({
+    endpoints: z
+        .array(z.lazy(() => unmarshalInferenceEndpointSchema))
+        .optional(),
+})
+    .transform(d => ({
+    endpoints: d.endpoints,
+}));
+export const unmarshalModelDataPlaneInfoSchema = z
+    .object({
+    query_info: z.lazy(() => unmarshalDataPlaneInfoSchema).optional(),
+})
+    .transform(d => ({
+    queryInfo: d.query_info,
+}));
+export const unmarshalOpenAiConfigSchema = z
+    .object({
+    openai_api_key: z.string().optional(),
+    openai_api_type: z.string().optional(),
+    openai_api_base: z.string().optional(),
+    openai_api_version: z.string().optional(),
+    openai_deployment_name: z.string().optional(),
+    openai_organization: z.string().optional(),
+    microsoft_entra_tenant_id: z.string().optional(),
+    microsoft_entra_client_id: z.string().optional(),
+    microsoft_entra_client_secret: z.string().optional(),
+    openai_api_key_plaintext: z.string().optional(),
+    microsoft_entra_client_secret_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    openaiApiKey: d.openai_api_key,
+    openaiApiType: d.openai_api_type,
+    openaiApiBase: d.openai_api_base,
+    openaiApiVersion: d.openai_api_version,
+    openaiDeploymentName: d.openai_deployment_name,
+    openaiOrganization: d.openai_organization,
+    microsoftEntraTenantId: d.microsoft_entra_tenant_id,
+    microsoftEntraClientId: d.microsoft_entra_client_id,
+    microsoftEntraClientSecret: d.microsoft_entra_client_secret,
+    openaiApiKeyPlaintext: d.openai_api_key_plaintext,
+    microsoftEntraClientSecretPlaintext: d.microsoft_entra_client_secret_plaintext,
+}));
+export const unmarshalPaLmConfigSchema = z
+    .object({
+    palm_api_key: z.string().optional(),
+    palm_api_key_plaintext: z.string().optional(),
+})
+    .transform(d => ({
+    palmApiKey: d.palm_api_key,
+    palmApiKeyPlaintext: d.palm_api_key_plaintext,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalPatchInferenceEndpointTagsRequest_ResponseSchema = z
+    .object({
+    tags: z.array(z.lazy(() => unmarshalEndpointTagSchema)).optional(),
+})
+    .transform(d => ({
+    tags: d.tags,
+}));
+export const unmarshalPayloadTableSchema = z
+    .object({
+    name: z.string().optional(),
+    status: z.string().optional(),
+    status_message: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    status: d.status,
+    statusMessage: d.status_message,
+}));
+export const unmarshalPendingConfigSchema = z
+    .object({
+    served_entities: z
+        .array(z.lazy(() => unmarshalServedModelSchema))
+        .optional(),
+    served_models: z.array(z.lazy(() => unmarshalServedModelSchema)).optional(),
+    traffic_config: z.lazy(() => unmarshalTrafficConfigSchema).optional(),
+    config_version: z.number().optional(),
+    start_time: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    auto_capture_config: z
+        .lazy(() => unmarshalAutoCaptureConfigSchema)
+        .optional(),
+})
+    .transform(d => ({
+    servedEntities: d.served_entities,
+    servedModels: d.served_models,
+    trafficConfig: d.traffic_config,
+    configVersion: d.config_version,
+    startTime: d.start_time,
+    autoCaptureConfig: d.auto_capture_config,
+}));
+export const unmarshalPiiSettingsSchema = z
+    .object({
+    behavior: z.enum(Behavior).optional(),
+})
+    .transform(d => ({
+    behavior: d.behavior,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalPutInferenceEndpointAiGatewayRequest_ResponseSchema = z
+    .object({
+    usage_tracking_config: z
+        .lazy(() => unmarshalUsageTrackingConfigSchema)
+        .optional(),
+    inference_table_config: z
+        .lazy(() => unmarshalInferenceTableConfigSchema)
+        .optional(),
+    rate_limits: z
+        .array(z.lazy(() => unmarshalAiGatewayRateLimitSchema))
+        .optional(),
+    guardrails: z.lazy(() => unmarshalAiGuardrailsSchema).optional(),
+    fallback_config: z.lazy(() => unmarshalFallbackConfigSchema).optional(),
+})
+    .transform(d => ({
+    usageTrackingConfig: d.usage_tracking_config,
+    inferenceTableConfig: d.inference_table_config,
+    rateLimits: d.rate_limits,
+    guardrails: d.guardrails,
+    fallbackConfig: d.fallback_config,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalPutInferenceEndpointRateLimitsRequest_ResponseSchema = z
+    .object({
+    rate_limits: z.array(z.lazy(() => unmarshalRateLimitSchema)).optional(),
+})
+    .transform(d => ({
+    rateLimits: d.rate_limits,
+}));
+export const unmarshalRateLimitSchema = z
+    .object({
+    calls: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    key: z.string().optional(),
+    renewal_period: z.string().optional(),
+})
+    .transform(d => ({
+    calls: d.calls,
+    key: d.key,
+    renewalPeriod: d.renewal_period,
+}));
+export const unmarshalRouteSchema = z
+    .object({
+    served_model_name: z.string().optional(),
+    traffic_percentage: z.number().optional(),
+    served_entity_name: z.string().optional(),
+})
+    .transform(d => ({
+    servedModelName: d.served_model_name,
+    trafficPercentage: d.traffic_percentage,
+    servedEntityName: d.served_entity_name,
+}));
+export const unmarshalServedModelSchema = z
+    .object({
+    name: z.string().optional(),
+    external_model: z.lazy(() => unmarshalExternalModelSchema).optional(),
+    entity_name: z.string().optional(),
+    entity_version: z.string().optional(),
+    min_provisioned_throughput: z.number().optional(),
+    max_provisioned_throughput: z.number().optional(),
+    min_provisioned_concurrency: z.number().optional(),
+    max_provisioned_concurrency: z.number().optional(),
+    workload_size: z.string().optional(),
+    provisioned_model_units: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    burst_scaling_enabled: z.boolean().optional(),
+    scale_to_zero_enabled: z.boolean().optional(),
+    model_name: z.string().optional(),
+    model_version: z.string().optional(),
+    environment_vars: z.record(z.string(), z.string()).optional(),
+    instance_profile_arn: z.string().optional(),
+    foundation_model: z.lazy(() => unmarshalFoundationModelSchema).optional(),
+    state: z.lazy(() => unmarshalServedModelStateSchema).optional(),
+    creator: z.string().optional(),
+    creation_timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    externalModel: d.external_model,
+    entityName: d.entity_name,
+    entityVersion: d.entity_version,
+    minProvisionedThroughput: d.min_provisioned_throughput,
+    maxProvisionedThroughput: d.max_provisioned_throughput,
+    minProvisionedConcurrency: d.min_provisioned_concurrency,
+    maxProvisionedConcurrency: d.max_provisioned_concurrency,
+    workloadSize: d.workload_size,
+    provisionedModelUnits: d.provisioned_model_units,
+    burstScalingEnabled: d.burst_scaling_enabled,
+    scaleToZeroEnabled: d.scale_to_zero_enabled,
+    modelName: d.model_name,
+    modelVersion: d.model_version,
+    environmentVars: d.environment_vars,
+    instanceProfileArn: d.instance_profile_arn,
+    foundationModel: d.foundation_model,
+    state: d.state,
+    creator: d.creator,
+    creationTimestamp: d.creation_timestamp,
+}));
+export const unmarshalServedModelLiteSchema = z
+    .object({
+    name: z.string().optional(),
+    model_name: z.string().optional(),
+    entity_name: z.string().optional(),
+    model_version: z.string().optional(),
+    entity_version: z.string().optional(),
+    external_model: z.lazy(() => unmarshalExternalModelSchema).optional(),
+    foundation_model: z.lazy(() => unmarshalFoundationModelSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    modelName: d.model_name,
+    entityName: d.entity_name,
+    modelVersion: d.model_version,
+    entityVersion: d.entity_version,
+    externalModel: d.external_model,
+    foundationModel: d.foundation_model,
+}));
+export const unmarshalServedModelStateSchema = z
+    .object({
+    deployment: z.enum(ServedModelDeploymentState).optional(),
+    deployment_state_message: z.string().optional(),
+})
+    .transform(d => ({
+    deployment: d.deployment,
+    deploymentStateMessage: d.deployment_state_message,
+}));
+export const unmarshalTrafficConfigSchema = z
+    .object({
+    routes: z.array(z.lazy(() => unmarshalRouteSchema)).optional(),
+})
+    .transform(d => ({
+    routes: d.routes,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalUpdateInferenceEndpointNotificationsRequest_ResponseSchema = z
+    .object({
+    name: z.string().optional(),
+    email_notifications: z
+        .lazy(() => unmarshalEmailNotificationsSchema)
+        .optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    emailNotifications: d.email_notifications,
+}));
+export const unmarshalUsageTrackingConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    enabled: d.enabled,
+}));
+export const marshalAi21LabsConfigSchema = z
+    .object({
+    ai21labsApiKey: z.string().optional(),
+    ai21labsApiKeyPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    ai21labs_api_key: d.ai21labsApiKey,
+    ai21labs_api_key_plaintext: d.ai21labsApiKeyPlaintext,
+}));
+export const marshalAiGatewayConfigSchema = z
+    .object({
+    usageTrackingConfig: z
+        .lazy(() => marshalUsageTrackingConfigSchema)
+        .optional(),
+    inferenceTableConfig: z
+        .lazy(() => marshalInferenceTableConfigSchema)
+        .optional(),
+    rateLimits: z
+        .array(z.lazy(() => marshalAiGatewayRateLimitSchema))
+        .optional(),
+    guardrails: z.lazy(() => marshalAiGuardrailsSchema).optional(),
+    fallbackConfig: z.lazy(() => marshalFallbackConfigSchema).optional(),
+})
+    .transform(d => ({
+    usage_tracking_config: d.usageTrackingConfig,
+    inference_table_config: d.inferenceTableConfig,
+    rate_limits: d.rateLimits,
+    guardrails: d.guardrails,
+    fallback_config: d.fallbackConfig,
+}));
+export const marshalAiGatewayRateLimitSchema = z
+    .object({
+    calls: z.bigint().optional(),
+    key: z.string().optional(),
+    renewalPeriod: z.string().optional(),
+    principal: z.string().optional(),
+    tokens: z.bigint().optional(),
+})
+    .transform(d => ({
+    calls: d.calls,
+    key: d.key,
+    renewal_period: d.renewalPeriod,
+    principal: d.principal,
+    tokens: d.tokens,
+}));
+export const marshalAiGuardrailParametersSchema = z
+    .object({
+    safety: z.boolean().optional(),
+    pii: z.lazy(() => marshalPiiSettingsSchema).optional(),
+    validTopics: z.array(z.string()).optional(),
+    invalidKeywords: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    safety: d.safety,
+    pii: d.pii,
+    valid_topics: d.validTopics,
+    invalid_keywords: d.invalidKeywords,
+}));
+export const marshalAiGuardrailsSchema = z
+    .object({
+    input: z.lazy(() => marshalAiGuardrailParametersSchema).optional(),
+    output: z.lazy(() => marshalAiGuardrailParametersSchema).optional(),
+})
+    .transform(d => ({
+    input: d.input,
+    output: d.output,
+}));
+export const marshalAmazonBedrockConfigSchema = z
+    .object({
+    awsRegion: z.string().optional(),
+    awsAccessKeyId: z.string().optional(),
+    awsSecretAccessKey: z.string().optional(),
+    bedrockProvider: z.string().optional(),
+    awsAccessKeyIdPlaintext: z.string().optional(),
+    awsSecretAccessKeyPlaintext: z.string().optional(),
+    instanceProfileArn: z.string().optional(),
+})
+    .transform(d => ({
+    aws_region: d.awsRegion,
+    aws_access_key_id: d.awsAccessKeyId,
+    aws_secret_access_key: d.awsSecretAccessKey,
+    bedrock_provider: d.bedrockProvider,
+    aws_access_key_id_plaintext: d.awsAccessKeyIdPlaintext,
+    aws_secret_access_key_plaintext: d.awsSecretAccessKeyPlaintext,
+    instance_profile_arn: d.instanceProfileArn,
+}));
+export const marshalAnthropicConfigSchema = z
+    .object({
+    anthropicApiKey: z.string().optional(),
+    anthropicApiKeyPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    anthropic_api_key: d.anthropicApiKey,
+    anthropic_api_key_plaintext: d.anthropicApiKeyPlaintext,
+}));
+export const marshalApiKeyAuthSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+    valuePlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+    value_plaintext: d.valuePlaintext,
+}));
+export const marshalAutoCaptureConfigSchema = z
+    .object({
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableNamePrefix: z.string().optional(),
+    state: z.lazy(() => marshalAutoCaptureStateSchema).optional(),
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_name_prefix: d.tableNamePrefix,
+    state: d.state,
+    enabled: d.enabled,
+}));
+export const marshalAutoCaptureStateSchema = z
+    .object({
+    payloadTable: z.lazy(() => marshalPayloadTableSchema).optional(),
+})
+    .transform(d => ({
+    payload_table: d.payloadTable,
+}));
+export const marshalBearerTokenAuthSchema = z
+    .object({
+    token: z.string().optional(),
+    tokenPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    token: d.token,
+    token_plaintext: d.tokenPlaintext,
+}));
+export const marshalCohereConfigSchema = z
+    .object({
+    cohereApiKey: z.string().optional(),
+    cohereApiKeyPlaintext: z.string().optional(),
+    cohereApiBase: z.string().optional(),
+})
+    .transform(d => ({
+    cohere_api_key: d.cohereApiKey,
+    cohere_api_key_plaintext: d.cohereApiKeyPlaintext,
+    cohere_api_base: d.cohereApiBase,
+}));
+export const marshalCreateInferenceEndpointRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    config: z.lazy(() => marshalEndpointCoreConfigSchema).optional(),
+    tags: z.array(z.lazy(() => marshalEndpointTagSchema)).optional(),
+    routeOptimized: z.boolean().optional(),
+    rateLimits: z.array(z.lazy(() => marshalRateLimitSchema)).optional(),
+    aiGateway: z.lazy(() => marshalAiGatewayConfigSchema).optional(),
+    budgetPolicyId: z.string().optional(),
+    emailNotifications: z
+        .lazy(() => marshalEmailNotificationsSchema)
+        .optional(),
+    description: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    config: d.config,
+    tags: d.tags,
+    route_optimized: d.routeOptimized,
+    rate_limits: d.rateLimits,
+    ai_gateway: d.aiGateway,
+    budget_policy_id: d.budgetPolicyId,
+    email_notifications: d.emailNotifications,
+    description: d.description,
+}));
+export const marshalCreatePtEndpointRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    config: z.lazy(() => marshalPtEndpointCoreConfigSchema).optional(),
+    tags: z.array(z.lazy(() => marshalEndpointTagSchema)).optional(),
+    aiGateway: z.lazy(() => marshalAiGatewayConfigSchema).optional(),
+    budgetPolicyId: z.string().optional(),
+    emailNotifications: z
+        .lazy(() => marshalEmailNotificationsSchema)
+        .optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    config: d.config,
+    tags: d.tags,
+    ai_gateway: d.aiGateway,
+    budget_policy_id: d.budgetPolicyId,
+    email_notifications: d.emailNotifications,
+}));
+export const marshalCustomProviderConfigSchema = z
+    .object({
+    customProviderUrl: z.string().optional(),
+    bearerTokenAuth: z.lazy(() => marshalBearerTokenAuthSchema).optional(),
+    apiKeyAuth: z.lazy(() => marshalApiKeyAuthSchema).optional(),
+})
+    .transform(d => ({
+    custom_provider_url: d.customProviderUrl,
+    bearer_token_auth: d.bearerTokenAuth,
+    api_key_auth: d.apiKeyAuth,
+}));
+export const marshalDatabricksModelServingConfigSchema = z
+    .object({
+    databricksApiToken: z.string().optional(),
+    databricksWorkspaceUrl: z.string().optional(),
+    databricksApiTokenPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    databricks_api_token: d.databricksApiToken,
+    databricks_workspace_url: d.databricksWorkspaceUrl,
+    databricks_api_token_plaintext: d.databricksApiTokenPlaintext,
+}));
+export const marshalEmailNotificationsSchema = z
+    .object({
+    onUpdateSuccess: z.array(z.string()).optional(),
+    onUpdateFailure: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    on_update_success: d.onUpdateSuccess,
+    on_update_failure: d.onUpdateFailure,
+}));
+export const marshalEndpointCoreConfigSchema = z
+    .object({
+    servedEntities: z.array(z.lazy(() => marshalServedModelSchema)).optional(),
+    servedModels: z.array(z.lazy(() => marshalServedModelSchema)).optional(),
+    trafficConfig: z.lazy(() => marshalTrafficConfigSchema).optional(),
+    autoCaptureConfig: z.lazy(() => marshalAutoCaptureConfigSchema).optional(),
+})
+    .transform(d => ({
+    served_entities: d.servedEntities,
+    served_models: d.servedModels,
+    traffic_config: d.trafficConfig,
+    auto_capture_config: d.autoCaptureConfig,
+}));
+export const marshalEndpointTagSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const marshalExternalFunctionRequestSchema = z
+    .object({
+    connectionName: z.string().optional(),
+    method: z.enum(ExternalFunctionRequest_HttpMethod).optional(),
+    path: z.string().optional(),
+    json: z.string().optional(),
+    headers: z.string().optional(),
+    params: z.string().optional(),
+    subDomain: z.string().optional(),
+})
+    .transform(d => ({
+    connection_name: d.connectionName,
+    method: d.method,
+    path: d.path,
+    json: d.json,
+    headers: d.headers,
+    params: d.params,
+    sub_domain: d.subDomain,
+}));
+export const marshalExternalModelSchema = z
+    .object({
+    provider: z.string().optional(),
+    name: z.string().optional(),
+    task: z.string().optional(),
+    config: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('ai21labsConfig'),
+            ai21labsConfig: z.lazy(() => marshalAi21LabsConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('anthropicConfig'),
+            anthropicConfig: z.lazy(() => marshalAnthropicConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('amazonBedrockConfig'),
+            amazonBedrockConfig: z.lazy(() => marshalAmazonBedrockConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('cohereConfig'),
+            cohereConfig: z.lazy(() => marshalCohereConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('googleCloudVertexAiConfig'),
+            googleCloudVertexAiConfig: z.lazy(() => marshalGoogleCloudVertexAiConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('databricksModelServingConfig'),
+            databricksModelServingConfig: z.lazy(() => marshalDatabricksModelServingConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('openaiConfig'),
+            openaiConfig: z.lazy(() => marshalOpenAiConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('palmConfig'),
+            palmConfig: z.lazy(() => marshalPaLmConfigSchema),
+        }),
+        z.object({
+            $case: z.literal('customProviderConfig'),
+            customProviderConfig: z.lazy(() => marshalCustomProviderConfigSchema),
+        }),
+    ])
+        .optional(),
+})
+    .transform(d => ({
+    provider: d.provider,
+    name: d.name,
+    task: d.task,
+    ...(d.config?.$case === 'ai21labsConfig' && {
+        ai21labs_config: d.config.ai21labsConfig,
+    }),
+    ...(d.config?.$case === 'anthropicConfig' && {
+        anthropic_config: d.config.anthropicConfig,
+    }),
+    ...(d.config?.$case === 'amazonBedrockConfig' && {
+        amazon_bedrock_config: d.config.amazonBedrockConfig,
+    }),
+    ...(d.config?.$case === 'cohereConfig' && {
+        cohere_config: d.config.cohereConfig,
+    }),
+    ...(d.config?.$case === 'googleCloudVertexAiConfig' && {
+        google_cloud_vertex_ai_config: d.config.googleCloudVertexAiConfig,
+    }),
+    ...(d.config?.$case === 'databricksModelServingConfig' && {
+        databricks_model_serving_config: d.config.databricksModelServingConfig,
+    }),
+    ...(d.config?.$case === 'openaiConfig' && {
+        openai_config: d.config.openaiConfig,
+    }),
+    ...(d.config?.$case === 'palmConfig' && { palm_config: d.config.palmConfig }),
+    ...(d.config?.$case === 'customProviderConfig' && {
+        custom_provider_config: d.config.customProviderConfig,
+    }),
+}));
+export const marshalFallbackConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    enabled: d.enabled,
+}));
+export const marshalFoundationModelSchema = z
+    .object({
+    name: z.string().optional(),
+    displayName: z.string().optional(),
+    docs: z.string().optional(),
+    description: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    display_name: d.displayName,
+    docs: d.docs,
+    description: d.description,
+}));
+export const marshalGoogleCloudVertexAiConfigSchema = z
+    .object({
+    privateKey: z.string().optional(),
+    projectId: z.string().optional(),
+    region: z.string().optional(),
+    privateKeyPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    private_key: d.privateKey,
+    project_id: d.projectId,
+    region: d.region,
+    private_key_plaintext: d.privateKeyPlaintext,
+}));
+export const marshalInferenceTableConfigSchema = z
+    .object({
+    catalogName: z.string().optional(),
+    schemaName: z.string().optional(),
+    tableNamePrefix: z.string().optional(),
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    catalog_name: d.catalogName,
+    schema_name: d.schemaName,
+    table_name_prefix: d.tableNamePrefix,
+    enabled: d.enabled,
+}));
+export const marshalOpenAiConfigSchema = z
+    .object({
+    openaiApiKey: z.string().optional(),
+    openaiApiType: z.string().optional(),
+    openaiApiBase: z.string().optional(),
+    openaiApiVersion: z.string().optional(),
+    openaiDeploymentName: z.string().optional(),
+    openaiOrganization: z.string().optional(),
+    microsoftEntraTenantId: z.string().optional(),
+    microsoftEntraClientId: z.string().optional(),
+    microsoftEntraClientSecret: z.string().optional(),
+    openaiApiKeyPlaintext: z.string().optional(),
+    microsoftEntraClientSecretPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    openai_api_key: d.openaiApiKey,
+    openai_api_type: d.openaiApiType,
+    openai_api_base: d.openaiApiBase,
+    openai_api_version: d.openaiApiVersion,
+    openai_deployment_name: d.openaiDeploymentName,
+    openai_organization: d.openaiOrganization,
+    microsoft_entra_tenant_id: d.microsoftEntraTenantId,
+    microsoft_entra_client_id: d.microsoftEntraClientId,
+    microsoft_entra_client_secret: d.microsoftEntraClientSecret,
+    openai_api_key_plaintext: d.openaiApiKeyPlaintext,
+    microsoft_entra_client_secret_plaintext: d.microsoftEntraClientSecretPlaintext,
+}));
+export const marshalPaLmConfigSchema = z
+    .object({
+    palmApiKey: z.string().optional(),
+    palmApiKeyPlaintext: z.string().optional(),
+})
+    .transform(d => ({
+    palm_api_key: d.palmApiKey,
+    palm_api_key_plaintext: d.palmApiKeyPlaintext,
+}));
+export const marshalPatchInferenceEndpointTagsRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    addTags: z.array(z.lazy(() => marshalEndpointTagSchema)).optional(),
+    deleteTags: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    add_tags: d.addTags,
+    delete_tags: d.deleteTags,
+}));
+export const marshalPayloadTableSchema = z
+    .object({
+    name: z.string().optional(),
+    status: z.string().optional(),
+    statusMessage: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    status: d.status,
+    status_message: d.statusMessage,
+}));
+export const marshalPiiSettingsSchema = z
+    .object({
+    behavior: z.enum(Behavior).optional(),
+})
+    .transform(d => ({
+    behavior: d.behavior,
+}));
+export const marshalPtEndpointCoreConfigSchema = z
+    .object({
+    servedEntities: z
+        .array(z.lazy(() => marshalPtServedModelSchema))
+        .optional(),
+    trafficConfig: z.lazy(() => marshalTrafficConfigSchema).optional(),
+})
+    .transform(d => ({
+    served_entities: d.servedEntities,
+    traffic_config: d.trafficConfig,
+}));
+export const marshalPtServedModelSchema = z
+    .object({
+    name: z.string().optional(),
+    entityName: z.string().optional(),
+    entityVersion: z.string().optional(),
+    provisionedModelUnits: z.bigint().optional(),
+    burstScalingEnabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    entity_name: d.entityName,
+    entity_version: d.entityVersion,
+    provisioned_model_units: d.provisionedModelUnits,
+    burst_scaling_enabled: d.burstScalingEnabled,
+}));
+export const marshalPutInferenceEndpointAiGatewayRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    usageTrackingConfig: z
+        .lazy(() => marshalUsageTrackingConfigSchema)
+        .optional(),
+    inferenceTableConfig: z
+        .lazy(() => marshalInferenceTableConfigSchema)
+        .optional(),
+    rateLimits: z
+        .array(z.lazy(() => marshalAiGatewayRateLimitSchema))
+        .optional(),
+    guardrails: z.lazy(() => marshalAiGuardrailsSchema).optional(),
+    fallbackConfig: z.lazy(() => marshalFallbackConfigSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    usage_tracking_config: d.usageTrackingConfig,
+    inference_table_config: d.inferenceTableConfig,
+    rate_limits: d.rateLimits,
+    guardrails: d.guardrails,
+    fallback_config: d.fallbackConfig,
+}));
+export const marshalPutInferenceEndpointConfigRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    servedEntities: z.array(z.lazy(() => marshalServedModelSchema)).optional(),
+    servedModels: z.array(z.lazy(() => marshalServedModelSchema)).optional(),
+    trafficConfig: z.lazy(() => marshalTrafficConfigSchema).optional(),
+    autoCaptureConfig: z.lazy(() => marshalAutoCaptureConfigSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    served_entities: d.servedEntities,
+    served_models: d.servedModels,
+    traffic_config: d.trafficConfig,
+    auto_capture_config: d.autoCaptureConfig,
+}));
+export const marshalPutInferenceEndpointRateLimitsRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    rateLimits: z.array(z.lazy(() => marshalRateLimitSchema)).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    rate_limits: d.rateLimits,
+}));
+export const marshalPutPtEndpointConfigRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    config: z.lazy(() => marshalPtEndpointCoreConfigSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    config: d.config,
+}));
+export const marshalRateLimitSchema = z
+    .object({
+    calls: z.bigint().optional(),
+    key: z.string().optional(),
+    renewalPeriod: z.string().optional(),
+})
+    .transform(d => ({
+    calls: d.calls,
+    key: d.key,
+    renewal_period: d.renewalPeriod,
+}));
+export const marshalRouteSchema = z
+    .object({
+    servedModelName: z.string().optional(),
+    trafficPercentage: z.number().optional(),
+    servedEntityName: z.string().optional(),
+})
+    .transform(d => ({
+    served_model_name: d.servedModelName,
+    traffic_percentage: d.trafficPercentage,
+    served_entity_name: d.servedEntityName,
+}));
+export const marshalServedModelSchema = z
+    .object({
+    name: z.string().optional(),
+    externalModel: z.lazy(() => marshalExternalModelSchema).optional(),
+    entityName: z.string().optional(),
+    entityVersion: z.string().optional(),
+    minProvisionedThroughput: z.number().optional(),
+    maxProvisionedThroughput: z.number().optional(),
+    minProvisionedConcurrency: z.number().optional(),
+    maxProvisionedConcurrency: z.number().optional(),
+    workloadSize: z.string().optional(),
+    provisionedModelUnits: z.bigint().optional(),
+    burstScalingEnabled: z.boolean().optional(),
+    scaleToZeroEnabled: z.boolean().optional(),
+    modelName: z.string().optional(),
+    modelVersion: z.string().optional(),
+    environmentVars: z.record(z.string(), z.string()).optional(),
+    instanceProfileArn: z.string().optional(),
+    foundationModel: z.lazy(() => marshalFoundationModelSchema).optional(),
+    state: z.lazy(() => marshalServedModelStateSchema).optional(),
+    creator: z.string().optional(),
+    creationTimestamp: z.bigint().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    external_model: d.externalModel,
+    entity_name: d.entityName,
+    entity_version: d.entityVersion,
+    min_provisioned_throughput: d.minProvisionedThroughput,
+    max_provisioned_throughput: d.maxProvisionedThroughput,
+    min_provisioned_concurrency: d.minProvisionedConcurrency,
+    max_provisioned_concurrency: d.maxProvisionedConcurrency,
+    workload_size: d.workloadSize,
+    provisioned_model_units: d.provisionedModelUnits,
+    burst_scaling_enabled: d.burstScalingEnabled,
+    scale_to_zero_enabled: d.scaleToZeroEnabled,
+    model_name: d.modelName,
+    model_version: d.modelVersion,
+    environment_vars: d.environmentVars,
+    instance_profile_arn: d.instanceProfileArn,
+    foundation_model: d.foundationModel,
+    state: d.state,
+    creator: d.creator,
+    creation_timestamp: d.creationTimestamp,
+}));
+export const marshalServedModelStateSchema = z
+    .object({
+    deployment: z.enum(ServedModelDeploymentState).optional(),
+    deploymentStateMessage: z.string().optional(),
+})
+    .transform(d => ({
+    deployment: d.deployment,
+    deployment_state_message: d.deploymentStateMessage,
+}));
+export const marshalTrafficConfigSchema = z
+    .object({
+    routes: z.array(z.lazy(() => marshalRouteSchema)).optional(),
+})
+    .transform(d => ({
+    routes: d.routes,
+}));
+export const marshalUpdateInferenceEndpointNotificationsRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    emailNotifications: z
+        .lazy(() => marshalEmailNotificationsSchema)
+        .optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    email_notifications: d.emailNotifications,
+}));
+export const marshalUsageTrackingConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+})
+    .transform(d => ({
+    enabled: d.enabled,
+}));
+//# sourceMappingURL=model.js.map