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

package/dist/v1/model.js

@@ -0,0 +1,797 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+import { z } from 'zod';
+const jsonValueSchema = z.lazy(() => z.union([
+    z.null(),
+    z.number(),
+    z.string(),
+    z.boolean(),
+    z.record(z.string(), jsonValueSchema),
+    z.array(jsonValueSchema),
+]));
+/** Type of endpoint. */
+export var EndpointType;
+(function (EndpointType) {
+    EndpointType["STORAGE_OPTIMIZED"] = "STORAGE_OPTIMIZED";
+    EndpointType["STANDARD"] = "STANDARD";
+})(EndpointType || (EndpointType = {}));
+/**
+ * The subtype of the AI Search index, determining the indexing and retrieval strategy.
+ * - `VECTOR`: Not supported. Use `HYBRID` instead.
+ * - `FULL_TEXT`: An index that uses full-text search without vector embeddings.
+ * - `HYBRID`: An index that uses vector embeddings for similarity search and hybrid search.
+ */
+export var IndexSubtype;
+(function (IndexSubtype) {
+    IndexSubtype["VECTOR"] = "VECTOR";
+    IndexSubtype["FULL_TEXT"] = "FULL_TEXT";
+    IndexSubtype["HYBRID"] = "HYBRID";
+})(IndexSubtype || (IndexSubtype = {}));
+/**
+ * Pipeline execution mode.
+ * - `TRIGGERED`: If the pipeline uses the triggered execution mode, the system stops processing after successfully refreshing the source table in the pipeline once, ensuring the table is updated based on the data available when the update started.
+ * - `CONTINUOUS`: If the pipeline uses continuous execution, the pipeline processes new data as it arrives in the source table to keep vector index fresh.
+ */
+export var PipelineType;
+(function (PipelineType) {
+    PipelineType["TRIGGERED"] = "TRIGGERED";
+    PipelineType["CONTINUOUS"] = "CONTINUOUS";
+})(PipelineType || (PipelineType = {}));
+export var ScalingChangeState;
+(function (ScalingChangeState) {
+    ScalingChangeState["SCALING_CHANGE_UNSPECIFIED"] = "SCALING_CHANGE_UNSPECIFIED";
+    ScalingChangeState["SCALING_CHANGE_APPLIED"] = "SCALING_CHANGE_APPLIED";
+    ScalingChangeState["SCALING_CHANGE_IN_PROGRESS"] = "SCALING_CHANGE_IN_PROGRESS";
+})(ScalingChangeState || (ScalingChangeState = {}));
+export var UpsertDeleteDataStatus;
+(function (UpsertDeleteDataStatus) {
+    UpsertDeleteDataStatus["SUCCESS"] = "SUCCESS";
+    UpsertDeleteDataStatus["PARTIAL_SUCCESS"] = "PARTIAL_SUCCESS";
+    UpsertDeleteDataStatus["FAILURE"] = "FAILURE";
+})(UpsertDeleteDataStatus || (UpsertDeleteDataStatus = {}));
+/**
+ * There are 2 types of AI Search indexes:
+ * - `DELTA_SYNC`: An index that automatically syncs with a source Delta Table, automatically and incrementally updating the index as the underlying data in the Delta Table changes.
+ * - `DIRECT_ACCESS`: An index that supports direct read and write of vectors and metadata through our REST and SDK APIs. With this model, the user manages index updates.
+ */
+export var VectorIndexType;
+(function (VectorIndexType) {
+    VectorIndexType["DELTA_SYNC"] = "DELTA_SYNC";
+    VectorIndexType["DIRECT_ACCESS"] = "DIRECT_ACCESS";
+})(VectorIndexType || (VectorIndexType = {}));
+/** Current state of the endpoint */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested enum name.
+export var EndpointStatus_State;
+(function (EndpointStatus_State) {
+    EndpointStatus_State["PROVISIONING"] = "PROVISIONING";
+    EndpointStatus_State["ONLINE"] = "ONLINE";
+    EndpointStatus_State["OFFLINE"] = "OFFLINE";
+    /**
+     * After the endpoint is ready, it can be in one of the following states:
+     * - RED_STATE: The endpoint is unhealthy and needs to be investigated.
+     * - YELLOW_STATE: The endpoint is healthy but needs to be monitored.
+     * - ONLINE: The endpoint is healthy and ready to serve traffic.
+     */
+    EndpointStatus_State["RED_STATE"] = "RED_STATE";
+    EndpointStatus_State["YELLOW_STATE"] = "YELLOW_STATE";
+    /**
+     * The endpoint is being deleted or has been deleted. Associated resources
+     * are being cleaned up; once cleanup completes the endpoint will no longer
+     * be retrievable.
+     */
+    EndpointStatus_State["DELETED"] = "DELETED";
+})(EndpointStatus_State || (EndpointStatus_State = {}));
+export const unmarshalColumnInfoSchema = z
+    .object({
+    name: z.string().optional(),
+    type_text: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    typeText: d.type_text,
+}));
+export const unmarshalCustomTagSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const unmarshalDeleteDataVectorIndexResponseSchema = z
+    .object({
+    status: z.enum(UpsertDeleteDataStatus).optional(),
+    result: z.lazy(() => unmarshalUpsertDeleteDataResultSchema).optional(),
+})
+    .transform(d => ({
+    status: d.status,
+    result: d.result,
+}));
+export const unmarshalDeleteEndpointResponseSchema = z.object({});
+export const unmarshalDeleteVectorIndexResponseSchema = z.object({});
+export const unmarshalDeltaSyncVectorIndexSpecSchema = z
+    .object({
+    source_table: z.string().optional(),
+    embedding_source_columns: z
+        .array(z.lazy(() => unmarshalEmbeddingSourceColumnSchema))
+        .optional(),
+    embedding_vector_columns: z
+        .array(z.lazy(() => unmarshalEmbeddingVectorColumnSchema))
+        .optional(),
+    pipeline_type: z.enum(PipelineType).optional(),
+    pipeline_id: z.string().optional(),
+    embedding_writeback_table: z.string().optional(),
+    columns_to_sync: z.array(z.string()).optional(),
+    columns_to_index: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    sourceTable: d.source_table,
+    embeddingSourceColumns: d.embedding_source_columns,
+    embeddingVectorColumns: d.embedding_vector_columns,
+    pipelineType: d.pipeline_type,
+    pipelineId: d.pipeline_id,
+    embeddingWritebackTable: d.embedding_writeback_table,
+    columnsToSync: d.columns_to_sync,
+    columnsToIndex: d.columns_to_index,
+}));
+export const unmarshalDirectAccessVectorIndexSpecSchema = z
+    .object({
+    embedding_vector_columns: z
+        .array(z.lazy(() => unmarshalEmbeddingVectorColumnSchema))
+        .optional(),
+    schema_json: z.string().optional(),
+    embedding_source_columns: z
+        .array(z.lazy(() => unmarshalEmbeddingSourceColumnSchema))
+        .optional(),
+})
+    .transform(d => ({
+    embeddingVectorColumns: d.embedding_vector_columns,
+    schemaJson: d.schema_json,
+    embeddingSourceColumns: d.embedding_source_columns,
+}));
+export const unmarshalEmbeddingSourceColumnSchema = z
+    .object({
+    name: z.string().optional(),
+    embedding_model_endpoint_name: z.string().optional(),
+    model_endpoint_name_for_query: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    embeddingConfig: d.embedding_model_endpoint_name !== undefined
+        ? {
+            $case: 'embeddingModelEndpointName',
+            embeddingModelEndpointName: d.embedding_model_endpoint_name,
+        }
+        : undefined,
+    modelEndpointNameForQuery: d.model_endpoint_name_for_query,
+}));
+export const unmarshalEmbeddingVectorColumnSchema = z
+    .object({
+    name: z.string().optional(),
+    embedding_dimension: z.number().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    embeddingDimension: d.embedding_dimension,
+}));
+export const unmarshalEndpointSchema = 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(),
+    endpoint_type: z.enum(EndpointType).optional(),
+    last_updated_user: z.string().optional(),
+    id: z.string().optional(),
+    endpoint_status: z.lazy(() => unmarshalEndpointStatusSchema).optional(),
+    num_indexes: z.number().optional(),
+    budget_policy_id: z.string().optional(),
+    effective_budget_policy_id: z.string().optional(),
+    custom_tags: z.array(z.lazy(() => unmarshalCustomTagSchema)).optional(),
+    scaling_info: z.lazy(() => unmarshalEndpointScalingInfoSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    creator: d.creator,
+    creationTimestamp: d.creation_timestamp,
+    lastUpdatedTimestamp: d.last_updated_timestamp,
+    endpointType: d.endpoint_type,
+    lastUpdatedUser: d.last_updated_user,
+    id: d.id,
+    endpointStatus: d.endpoint_status,
+    numIndexes: d.num_indexes,
+    budgetPolicyId: d.budget_policy_id,
+    effectiveBudgetPolicyId: d.effective_budget_policy_id,
+    customTags: d.custom_tags,
+    scalingInfo: d.scaling_info,
+}));
+export const unmarshalEndpointScalingInfoSchema = z
+    .object({
+    state: z.enum(ScalingChangeState).optional(),
+    requested_target_qps: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+})
+    .transform(d => ({
+    state: d.state,
+    requestedTargetQps: d.requested_target_qps,
+}));
+export const unmarshalEndpointStatusSchema = z
+    .object({
+    state: z.enum(EndpointStatus_State).optional(),
+    message: z.string().optional(),
+})
+    .transform(d => ({
+    state: d.state,
+    message: d.message,
+}));
+export const unmarshalListEndpointResponseSchema = z
+    .object({
+    endpoints: z.array(z.lazy(() => unmarshalEndpointSchema)).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    endpoints: d.endpoints,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalListValueSchema = z
+    .object({
+    values: z.array(z.lazy(() => unmarshalValueSchema)).optional(),
+})
+    .transform(d => ({
+    values: d.values,
+}));
+export const unmarshalListVectorIndexResponseSchema = z
+    .object({
+    vector_indexes: z
+        .array(z.lazy(() => unmarshalMiniVectorIndexSchema))
+        .optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    vectorIndexes: d.vector_indexes,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalMapStringValueEntrySchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.lazy(() => unmarshalValueSchema).optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const unmarshalMetricSchema = z
+    .object({
+    name: z.string().optional(),
+    labels: z.array(z.lazy(() => unmarshalMetricLabelSchema)).optional(),
+    percentile: z.number().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    labels: d.labels,
+    percentile: d.percentile,
+}));
+export const unmarshalMetricLabelSchema = z
+    .object({
+    name: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    value: d.value,
+}));
+export const unmarshalMetricValueSchema = z
+    .object({
+    timestamp: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    value: z.number().optional(),
+})
+    .transform(d => ({
+    timestamp: d.timestamp,
+    value: d.value,
+}));
+export const unmarshalMetricValuesSchema = z
+    .object({
+    metric: z.lazy(() => unmarshalMetricSchema).optional(),
+    values: z.array(z.lazy(() => unmarshalMetricValueSchema)).optional(),
+})
+    .transform(d => ({
+    metric: d.metric,
+    values: d.values,
+}));
+export const unmarshalMiniVectorIndexSchema = z
+    .object({
+    name: z.string().optional(),
+    endpoint_name: z.string().optional(),
+    primary_key: z.string().optional(),
+    index_type: z.enum(VectorIndexType).optional(),
+    direct_access_index_spec: z
+        .lazy(() => unmarshalDirectAccessVectorIndexSpecSchema)
+        .optional(),
+    delta_sync_index_spec: z
+        .lazy(() => unmarshalDeltaSyncVectorIndexSpecSchema)
+        .optional(),
+    status: z.lazy(() => unmarshalVectorIndexStatusSchema).optional(),
+    creator: z.string().optional(),
+    index_subtype: z.enum(IndexSubtype).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    endpointName: d.endpoint_name,
+    primaryKey: d.primary_key,
+    indexType: d.index_type,
+    indexSpec: d.direct_access_index_spec !== undefined
+        ? {
+            $case: 'directAccessIndexSpec',
+            directAccessIndexSpec: d.direct_access_index_spec,
+        }
+        : d.delta_sync_index_spec !== undefined
+            ? {
+                $case: 'deltaSyncIndexSpec',
+                deltaSyncIndexSpec: d.delta_sync_index_spec,
+            }
+            : undefined,
+    status: d.status,
+    creator: d.creator,
+    indexSubtype: d.index_subtype,
+}));
+export const unmarshalPatchEndpointBudgetPolicyResponseSchema = z
+    .object({
+    budget_policy_id: z.string().optional(),
+    effective_budget_policy_id: z.string().optional(),
+})
+    .transform(d => ({
+    budgetPolicyId: d.budget_policy_id,
+    effectiveBudgetPolicyId: d.effective_budget_policy_id,
+}));
+export const unmarshalQueryVectorIndexResponseSchema = z
+    .object({
+    manifest: z.lazy(() => unmarshalResultManifestSchema).optional(),
+    result: z.lazy(() => unmarshalResultDataSchema).optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    manifest: d.manifest,
+    result: d.result,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalResultDataSchema = z
+    .object({
+    row_count: z.number().optional(),
+    data_array: z.array(z.array(jsonValueSchema)).optional(),
+})
+    .transform(d => ({
+    rowCount: d.row_count,
+    dataArray: d.data_array,
+}));
+export const unmarshalResultManifestSchema = z
+    .object({
+    column_count: z.number().optional(),
+    columns: z.array(z.lazy(() => unmarshalColumnInfoSchema)).optional(),
+})
+    .transform(d => ({
+    columnCount: d.column_count,
+    columns: d.columns,
+}));
+export const unmarshalRetrieveUserVisibleMetricsResponseSchema = z
+    .object({
+    metric_values: z
+        .array(z.lazy(() => unmarshalMetricValuesSchema))
+        .optional(),
+    next_page_token: z.string().optional(),
+})
+    .transform(d => ({
+    metricValues: d.metric_values,
+    nextPageToken: d.next_page_token,
+}));
+export const unmarshalScanVectorIndexResponseSchema = z
+    .object({
+    data: z.array(z.lazy(() => unmarshalStructSchema)).optional(),
+    last_primary_key: z.string().optional(),
+})
+    .transform(d => ({
+    data: d.data,
+    lastPrimaryKey: d.last_primary_key,
+}));
+export const unmarshalStructSchema = z
+    .object({
+    fields: z
+        .array(z.lazy(() => unmarshalMapStringValueEntrySchema))
+        .optional(),
+})
+    .transform(d => ({
+    fields: d.fields,
+}));
+export const unmarshalSyncVectorIndexResponseSchema = z.object({});
+export const unmarshalUpdateEndpointCustomTagsResponseSchema = z
+    .object({
+    name: z.string().optional(),
+    custom_tags: z.array(z.lazy(() => unmarshalCustomTagSchema)).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    customTags: d.custom_tags,
+}));
+export const unmarshalUpsertDataVectorIndexResponseSchema = z
+    .object({
+    status: z.enum(UpsertDeleteDataStatus).optional(),
+    result: z.lazy(() => unmarshalUpsertDeleteDataResultSchema).optional(),
+})
+    .transform(d => ({
+    status: d.status,
+    result: d.result,
+}));
+export const unmarshalUpsertDeleteDataResultSchema = z
+    .object({
+    success_row_count: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    failed_primary_keys: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    successRowCount: d.success_row_count,
+    failedPrimaryKeys: d.failed_primary_keys,
+}));
+export const unmarshalValueSchema = z
+    .object({
+    number_value: z.number().optional(),
+    string_value: z.string().optional(),
+    bool_value: z.boolean().optional(),
+    struct_value: z.lazy(() => unmarshalStructSchema).optional(),
+    list_value: z.lazy(() => unmarshalListValueSchema).optional(),
+})
+    .transform(d => ({
+    kind: d.number_value !== undefined
+        ? { $case: 'numberValue', numberValue: d.number_value }
+        : d.string_value !== undefined
+            ? { $case: 'stringValue', stringValue: d.string_value }
+            : d.bool_value !== undefined
+                ? { $case: 'boolValue', boolValue: d.bool_value }
+                : d.struct_value !== undefined
+                    ? { $case: 'structValue', structValue: d.struct_value }
+                    : d.list_value !== undefined
+                        ? { $case: 'listValue', listValue: d.list_value }
+                        : undefined,
+}));
+export const unmarshalVectorIndexSchema = z
+    .object({
+    name: z.string().optional(),
+    endpoint_name: z.string().optional(),
+    primary_key: z.string().optional(),
+    index_type: z.enum(VectorIndexType).optional(),
+    direct_access_index_spec: z
+        .lazy(() => unmarshalDirectAccessVectorIndexSpecSchema)
+        .optional(),
+    delta_sync_index_spec: z
+        .lazy(() => unmarshalDeltaSyncVectorIndexSpecSchema)
+        .optional(),
+    status: z.lazy(() => unmarshalVectorIndexStatusSchema).optional(),
+    creator: z.string().optional(),
+    index_subtype: z.enum(IndexSubtype).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    endpointName: d.endpoint_name,
+    primaryKey: d.primary_key,
+    indexType: d.index_type,
+    indexSpec: d.direct_access_index_spec !== undefined
+        ? {
+            $case: 'directAccessIndexSpec',
+            directAccessIndexSpec: d.direct_access_index_spec,
+        }
+        : d.delta_sync_index_spec !== undefined
+            ? {
+                $case: 'deltaSyncIndexSpec',
+                deltaSyncIndexSpec: d.delta_sync_index_spec,
+            }
+            : undefined,
+    status: d.status,
+    creator: d.creator,
+    indexSubtype: d.index_subtype,
+}));
+export const unmarshalVectorIndexStatusSchema = z
+    .object({
+    message: z.string().optional(),
+    indexed_row_count: z
+        .union([z.number(), z.bigint()])
+        .transform(v => BigInt(v))
+        .optional(),
+    ready: z.boolean().optional(),
+    index_url: z.string().optional(),
+})
+    .transform(d => ({
+    message: d.message,
+    indexedRowCount: d.indexed_row_count,
+    ready: d.ready,
+    indexUrl: d.index_url,
+}));
+export const marshalCreateEndpointRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    endpointType: z.enum(EndpointType).optional(),
+    budgetPolicyId: z.string().optional(),
+    usagePolicyId: z.string().optional(),
+    targetQps: z.bigint().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    endpoint_type: d.endpointType,
+    budget_policy_id: d.budgetPolicyId,
+    usage_policy_id: d.usagePolicyId,
+    target_qps: d.targetQps,
+}));
+export const marshalCreateVectorIndexRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    endpointName: z.string().optional(),
+    primaryKey: z.string().optional(),
+    indexType: z.enum(VectorIndexType).optional(),
+    indexSpec: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('directAccessIndexSpec'),
+            directAccessIndexSpec: z.lazy(() => marshalDirectAccessVectorIndexSpecSchema),
+        }),
+        z.object({
+            $case: z.literal('deltaSyncIndexSpec'),
+            deltaSyncIndexSpec: z.lazy(() => marshalDeltaSyncVectorIndexSpecRequestSchema),
+        }),
+    ])
+        .optional(),
+    indexSubtype: z.enum(IndexSubtype).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    endpoint_name: d.endpointName,
+    primary_key: d.primaryKey,
+    index_type: d.indexType,
+    ...(d.indexSpec?.$case === 'directAccessIndexSpec' && {
+        direct_access_index_spec: d.indexSpec.directAccessIndexSpec,
+    }),
+    ...(d.indexSpec?.$case === 'deltaSyncIndexSpec' && {
+        delta_sync_index_spec: d.indexSpec.deltaSyncIndexSpec,
+    }),
+    index_subtype: d.indexSubtype,
+}));
+export const marshalCustomTagSchema = z
+    .object({
+    key: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    key: d.key,
+    value: d.value,
+}));
+export const marshalDeltaSyncVectorIndexSpecRequestSchema = z
+    .object({
+    sourceTable: z.string().optional(),
+    embeddingSourceColumns: z
+        .array(z.lazy(() => marshalEmbeddingSourceColumnSchema))
+        .optional(),
+    embeddingVectorColumns: z
+        .array(z.lazy(() => marshalEmbeddingVectorColumnSchema))
+        .optional(),
+    pipelineType: z.enum(PipelineType).optional(),
+    pipelineId: z.string().optional(),
+    embeddingWritebackTable: z.string().optional(),
+    columnsToSync: z.array(z.string()).optional(),
+    columnsToIndex: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    source_table: d.sourceTable,
+    embedding_source_columns: d.embeddingSourceColumns,
+    embedding_vector_columns: d.embeddingVectorColumns,
+    pipeline_type: d.pipelineType,
+    pipeline_id: d.pipelineId,
+    embedding_writeback_table: d.embeddingWritebackTable,
+    columns_to_sync: d.columnsToSync,
+    columns_to_index: d.columnsToIndex,
+}));
+export const marshalDirectAccessVectorIndexSpecSchema = z
+    .object({
+    embeddingVectorColumns: z
+        .array(z.lazy(() => marshalEmbeddingVectorColumnSchema))
+        .optional(),
+    schemaJson: z.string().optional(),
+    embeddingSourceColumns: z
+        .array(z.lazy(() => marshalEmbeddingSourceColumnSchema))
+        .optional(),
+})
+    .transform(d => ({
+    embedding_vector_columns: d.embeddingVectorColumns,
+    schema_json: d.schemaJson,
+    embedding_source_columns: d.embeddingSourceColumns,
+}));
+export const marshalEmbeddingSourceColumnSchema = z
+    .object({
+    name: z.string().optional(),
+    embeddingConfig: z
+        .discriminatedUnion('$case', [
+        z.object({
+            $case: z.literal('embeddingModelEndpointName'),
+            embeddingModelEndpointName: z.string(),
+        }),
+    ])
+        .optional(),
+    modelEndpointNameForQuery: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    ...(d.embeddingConfig?.$case === 'embeddingModelEndpointName' && {
+        embedding_model_endpoint_name: d.embeddingConfig.embeddingModelEndpointName,
+    }),
+    model_endpoint_name_for_query: d.modelEndpointNameForQuery,
+}));
+export const marshalEmbeddingVectorColumnSchema = z
+    .object({
+    name: z.string().optional(),
+    embeddingDimension: z.number().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    embedding_dimension: d.embeddingDimension,
+}));
+export const marshalMetricSchema = z
+    .object({
+    name: z.string().optional(),
+    labels: z.array(z.lazy(() => marshalMetricLabelSchema)).optional(),
+    percentile: z.number().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    labels: d.labels,
+    percentile: d.percentile,
+}));
+export const marshalMetricLabelSchema = z
+    .object({
+    name: z.string().optional(),
+    value: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    value: d.value,
+}));
+export const marshalPatchEndpointBudgetPolicyRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    budgetPolicyId: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    budget_policy_id: d.budgetPolicyId,
+}));
+export const marshalPatchEndpointRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    targetQps: z.bigint().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    target_qps: d.targetQps,
+}));
+export const marshalQueryVectorIndexNextPageRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    endpointName: z.string().optional(),
+    pageToken: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    endpoint_name: d.endpointName,
+    page_token: d.pageToken,
+}));
+export const marshalQueryVectorIndexRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    numResults: z.number().optional(),
+    columns: z.array(z.string()).optional(),
+    filtersJson: z.string().optional(),
+    queryVector: z.array(z.number()).optional(),
+    queryText: z.string().optional(),
+    scoreThreshold: z.number().optional(),
+    queryType: z.string().optional(),
+    columnsToRerank: z.array(z.string()).optional(),
+    reranker: z.lazy(() => marshalRerankerConfigSchema).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    num_results: d.numResults,
+    columns: d.columns,
+    filters_json: d.filtersJson,
+    query_vector: d.queryVector,
+    query_text: d.queryText,
+    score_threshold: d.scoreThreshold,
+    query_type: d.queryType,
+    columns_to_rerank: d.columnsToRerank,
+    reranker: d.reranker,
+}));
+export const marshalRerankerConfigSchema = z
+    .object({
+    model: z.string().optional(),
+    parameters: z
+        .lazy(() => marshalRerankerConfig_RerankerParametersSchema)
+        .optional(),
+})
+    .transform(d => ({
+    model: d.model,
+    parameters: d.parameters,
+}));
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const marshalRerankerConfig_RerankerParametersSchema = z
+    .object({
+    columnsToRerank: z.array(z.string()).optional(),
+})
+    .transform(d => ({
+    columns_to_rerank: d.columnsToRerank,
+}));
+export const marshalRetrieveUserVisibleMetricsRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    startTime: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    endTime: z
+        .any()
+        .transform((d) => d.toString())
+        .optional(),
+    granularityInSeconds: z.number().optional(),
+    metrics: z.array(z.lazy(() => marshalMetricSchema)).optional(),
+    pageToken: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    start_time: d.startTime,
+    end_time: d.endTime,
+    granularity_in_seconds: d.granularityInSeconds,
+    metrics: d.metrics,
+    page_token: d.pageToken,
+}));
+export const marshalScanVectorIndexRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    numResults: z.number().optional(),
+    lastPrimaryKey: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    num_results: d.numResults,
+    last_primary_key: d.lastPrimaryKey,
+}));
+export const marshalSyncVectorIndexRequestSchema = z
+    .object({
+    name: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+}));
+export const marshalUpdateEndpointCustomTagsRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    customTags: z.array(z.lazy(() => marshalCustomTagSchema)).optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    custom_tags: d.customTags,
+}));
+export const marshalUpsertDataVectorIndexRequestSchema = z
+    .object({
+    name: z.string().optional(),
+    inputsJson: z.string().optional(),
+})
+    .transform(d => ({
+    name: d.name,
+    inputs_json: d.inputsJson,
+}));
+//# sourceMappingURL=model.js.map