@metabase/client 0.0.0-stage → 0.1.0

package/dist/domain/transform-test.js

@@ -0,0 +1,176 @@
+import { z } from "zod";
+//#region src/domain/transform-test.ts
+const TransformTestTable = z.object({
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string().min(1)
+}).loose();
+const TransformTestColumn = z.object({
+	name: z.string().min(1),
+	cast_type: z.string().min(1)
+}).loose();
+const TransformTestCell = z.union([
+	z.boolean(),
+	z.number(),
+	z.string(),
+	z.null()
+]);
+const TransformTestRow = z.record(z.string(), TransformTestCell);
+const TransformTestSqlInput = z.object({
+	table: TransformTestTable,
+	format: z.literal("sql"),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestRowsInput = z.object({
+	table: TransformTestTable,
+	format: z.literal("rows"),
+	columns: z.array(TransformTestColumn).min(1),
+	rows: z.array(TransformTestRow)
+}).loose();
+const TransformTestInput = z.discriminatedUnion("format", [TransformTestSqlInput, TransformTestRowsInput]);
+const TransformTestEqualsSqlExpectation = z.object({
+	type: z.literal("equals"),
+	name: z.string().min(1),
+	format: z.literal("sql"),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestEqualsRowsExpectation = z.object({
+	type: z.literal("equals"),
+	name: z.string().min(1),
+	format: z.literal("rows"),
+	columns: z.array(TransformTestColumn).min(1),
+	rows: z.array(TransformTestRow)
+}).loose();
+const TransformTestEqualsExpectation = z.discriminatedUnion("format", [TransformTestEqualsSqlExpectation, TransformTestEqualsRowsExpectation]);
+const TransformTestEmptyExpectation = z.object({
+	type: z.literal("empty"),
+	name: z.string().min(1),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestExpectation = z.discriminatedUnion("type", [TransformTestEqualsExpectation, TransformTestEmptyExpectation]);
+const TransformTest = z.object({
+	id: z.number().int(),
+	entity_id: z.string(),
+	transform_id: z.number().int(),
+	creator_id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	inputs: z.array(TransformTestInput),
+	expectations: z.array(TransformTestExpectation),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const TransformTestCompact = TransformTest.pick({
+	id: true,
+	transform_id: true,
+	name: true,
+	description: true
+}).strip();
+/**
+* The server closes this map, so an unrecognized key is a 400 there. Refusing it here names the key
+* instead: a body cloned from `get` has to shed `id`, `entity_id`, `creator_id`, `created_at` and
+* `updated_at` before it can be sent back.
+*/
+const TransformTestCreateInput = z.object({
+	transform_id: z.number().int().positive(),
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	inputs: z.array(TransformTestInput),
+	expectations: z.array(TransformTestExpectation)
+}).strict();
+/** Closed for the same reason as [[TransformTestCreateInput]]; every field is optional. */
+const TransformTestUpdateInput = z.object({
+	transform_id: z.number().int().positive().optional(),
+	name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	inputs: z.array(TransformTestInput).optional(),
+	expectations: z.array(TransformTestExpectation).optional()
+}).strict();
+const TransformTestResultColumn = z.object({
+	name: z.string(),
+	database_type: z.string()
+}).loose();
+const TransformTestExpectationError = z.object({
+	type: z.string(),
+	message: z.string()
+}).loose();
+const TransformTestCellMismatch = z.object({
+	column: z.string(),
+	expected: TransformTestCell,
+	actual: TransformTestCell
+}).loose();
+const TransformTestRowCounts = z.object({
+	actual: z.number().int(),
+	expected: z.number().int()
+}).loose();
+const TransformTestEqualsFindings = z.object({
+	name: z.string(),
+	type: z.literal("equals"),
+	status: z.enum(["passed", "failed"]),
+	columns: z.array(TransformTestResultColumn),
+	"row-counts": TransformTestRowCounts,
+	"extra-rows": z.array(TransformTestRow),
+	"missing-rows": z.array(TransformTestRow),
+	"cell-mismatches": z.array(TransformTestCellMismatch),
+	truncated: z.number().int()
+}).loose();
+const TransformTestEqualsError = z.object({
+	name: z.string(),
+	type: z.literal("equals"),
+	status: z.literal("error"),
+	error: TransformTestExpectationError
+}).loose();
+const TransformTestEqualsResult = z.discriminatedUnion("status", [TransformTestEqualsFindings, TransformTestEqualsError]);
+const TransformTestEmptyPassed = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("passed")
+}).loose();
+const TransformTestEmptyFailed = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("failed"),
+	columns: z.array(TransformTestResultColumn),
+	sample: z.array(TransformTestRow),
+	truncated: z.number().int()
+}).loose();
+const TransformTestEmptyError = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("error"),
+	error: TransformTestExpectationError
+}).loose();
+const TransformTestEmptyResult = z.discriminatedUnion("status", [
+	TransformTestEmptyPassed,
+	TransformTestEmptyFailed,
+	TransformTestEmptyError
+]);
+const TransformTestExpectationResult = z.discriminatedUnion("type", [TransformTestEqualsResult, TransformTestEmptyResult]);
+const TransformTestRunResult = z.object({
+	status: z.enum([
+		"passed",
+		"failed",
+		"error"
+	]),
+	expectations: z.array(TransformTestExpectationResult),
+	tables: z.record(z.string(), z.string())
+}).loose();
+const TransformTestRefusalCode = z.enum([
+	"transform-test.unknown-column",
+	"transform-test.ambiguous-column",
+	"transform-test.missing-inputs",
+	"transform-test.unused-inputs",
+	"transform-test.duplicate-input-table",
+	"transform-test.unparseable-source",
+	"transform-test.unremapped-reference",
+	"transform-test.unsupported-transform",
+	"transform-test.unsupported-driver",
+	"transform-test.transform-failed",
+	"transform-test.setup-failed",
+	"transform-test.expectation-failed",
+	"transform-test.unsupported-format"
+]);
+function isTransformTestRefusalCode(value) {
+	return TransformTestRefusalCode.safeParse(value).success;
+}
+//#endregion
+export { TransformTest, TransformTestColumn, TransformTestCompact, TransformTestCreateInput, TransformTestExpectation, TransformTestExpectationResult, TransformTestInput, TransformTestRefusalCode, TransformTestResultColumn, TransformTestRow, TransformTestRunResult, TransformTestTable, TransformTestUpdateInput, isTransformTestRefusalCode };

package/dist/domain/transform.d.ts

@@ -0,0 +1,2 @@
+import { S as transformRowSchema, _ as TransformTarget, a as TransformDagRunResult, b as isTransformRunTerminal, c as TransformRunCompact, d as TransformRunStatus, f as TransformRunSummary, g as TransformSourceTableEntry, h as TransformRunSummaryType, i as TransformDagDirection, l as TransformRunMethod, m as TransformRunSummarySortColumn, n as TransformCompact, o as TransformDagTransform, p as TransformRunSummaryCompact, r as TransformCreateInput, s as TransformRun, t as Transform, u as TransformRunResult, v as TransformUpdateInput, x as transformDetailSchema, y as isTransformRunFailed } from "../transform-CDurgE1D.js";
+export { Transform, TransformCompact, TransformCreateInput, TransformDagDirection, TransformDagRunResult, TransformDagTransform, TransformRun, TransformRunCompact, TransformRunMethod, TransformRunResult, TransformRunStatus, TransformRunSummary, TransformRunSummaryCompact, TransformRunSummarySortColumn, TransformRunSummaryType, TransformSourceTableEntry, TransformTarget, TransformUpdateInput, isTransformRunFailed, isTransformRunTerminal, transformDetailSchema, transformRowSchema };

package/dist/domain/transform.js

@@ -0,0 +1,235 @@
+import { z } from "zod";
+//#region src/domain/transform.ts
+const TransformSourceType = z.enum([
+	"native",
+	"mbql",
+	"python"
+]);
+const TransformRunStatus = z.enum([
+	"started",
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled",
+	"canceling"
+]);
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled"
+]);
+const FAILURE_STATUSES = /* @__PURE__ */ new Set([
+	"failed",
+	"timeout",
+	"canceled"
+]);
+/** Whether the server will report any further progress for a run in this status. */
+function isTransformRunTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+/** Whether a terminal status means the run did not produce its target table. */
+function isTransformRunFailed(status) {
+	return FAILURE_STATUSES.has(status);
+}
+const TransformRunMethod = z.enum(["manual", "cron"]);
+const TransformRunTrigger = z.enum(["none", "global-schedule"]);
+const TransformCheckpointStrategy = z.object({
+	type: z.literal("checkpoint"),
+	"checkpoint-filter-field-id": z.number().int().positive().optional()
+}).loose();
+const TransformSourceTableEntry = z.object({
+	alias: z.string(),
+	database_id: z.number().int(),
+	schema: z.string().nullable(),
+	table: z.string().optional(),
+	table_id: z.number().int().nullable().optional()
+}).loose();
+const TransformQuerySource = z.object({
+	type: z.literal("query"),
+	query: z.unknown().describe("Native SQL or MBQL query"),
+	"source-incremental-strategy": TransformCheckpointStrategy.optional()
+}).loose();
+const TransformPythonSource = z.object({
+	type: z.literal("python"),
+	body: z.string(),
+	"source-tables": z.array(TransformSourceTableEntry),
+	"source-database": z.number().int().optional(),
+	"source-incremental-strategy": TransformCheckpointStrategy.optional()
+}).loose();
+const TransformSource = z.discriminatedUnion("type", [TransformQuerySource, TransformPythonSource]);
+const TransformAppendStrategy = z.object({ type: z.literal("append") }).loose();
+const TransformMergeKeyColumn = z.object({
+	name: z.string().min(1).optional(),
+	"field-id": z.number().int().positive().nullable().optional()
+}).loose();
+const TransformMergeStrategy = z.object({
+	type: z.literal("merge"),
+	"unique-key": z.array(TransformMergeKeyColumn)
+}).loose();
+const TransformTargetIncrementalStrategy = z.discriminatedUnion("type", [TransformAppendStrategy, TransformMergeStrategy]);
+const TransformTableTarget = z.object({
+	type: z.literal("table"),
+	database: z.number().int().optional(),
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string()
+}).loose();
+const TransformTableIncrementalTarget = z.object({
+	type: z.literal("table-incremental"),
+	database: z.number().int().optional(),
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string(),
+	"target-incremental-strategy": TransformTargetIncrementalStrategy
+}).loose();
+const TransformTarget = z.discriminatedUnion("type", [TransformTableTarget, TransformTableIncrementalTarget]);
+const TransformTargetCompact = z.discriminatedUnion("type", [TransformTableTarget.strip(), TransformTableIncrementalTarget.strip()]);
+const TransformLastRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int().nullable(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	is_active: z.boolean().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRunCompact = TransformRun.pick({
+	id: true,
+	transform_id: true,
+	status: true,
+	run_method: true,
+	start_time: true,
+	end_time: true,
+	message: true
+}).strip();
+const TransformRunResult = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable(),
+	final: TransformRun.nullable(),
+	target_table_id: z.number().int().nullable().optional()
+});
+/** Which transforms a DAG reprocess from a seed transform runs, besides the seed itself. */
+const TransformDagDirection = z.enum(["upstream", "downstream"]);
+const TransformDagRunResult = z.object({
+	message: z.string(),
+	dag_run_id: z.number().int().positive().nullable()
+});
+const TransformDagTransform = z.object({
+	id: z.number().int(),
+	name: z.string()
+});
+const TransformRunSummaryType = z.enum([
+	"job",
+	"dag",
+	"transform"
+]);
+const TransformRunSummarySortColumn = z.enum(["start_time", "end_time"]);
+const TransformRunSummary = z.object({
+	run_type: TransformRunSummaryType,
+	id: z.number().int(),
+	entity_id: z.number().int().nullable(),
+	name: z.string().nullable(),
+	direction: TransformDagDirection.nullable(),
+	transform_count: z.number().int().nullable(),
+	run_method: TransformRunMethod.nullable(),
+	status: TransformRunStatus,
+	is_active: z.boolean().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRunSummaryCompact = TransformRunSummary.pick({
+	run_type: true,
+	id: true,
+	entity_id: true,
+	name: true,
+	status: true,
+	run_method: true,
+	start_time: true,
+	end_time: true,
+	message: true
+}).strip();
+const TransformBase = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	source: TransformSource,
+	target: TransformTarget,
+	source_type: TransformSourceType,
+	source_database_id: z.number().int().nullable().optional(),
+	target_db_id: z.number().int().nullable().optional(),
+	entity_id: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	creator_id: z.number().int(),
+	collection_id: z.number().int().nullable(),
+	run_trigger: TransformRunTrigger.nullable().optional(),
+	last_run: TransformLastRun.nullable().optional(),
+	tag_ids: z.array(z.number().int()).optional()
+}).loose();
+const Transform = TransformBase.extend({ target_table_id: z.number().int().nullable() });
+const TransformWireV59Detail = TransformBase.extend({ table: z.object({ id: z.number().int() }).loose().nullable() });
+function fromHydratedTable(wire) {
+	return {
+		...wire,
+		target_table_id: wire.table === null ? null : wire.table.id
+	};
+}
+function withoutLink(row) {
+	return {
+		...row,
+		target_table_id: null
+	};
+}
+/** The shape `GET /api/transform/{id}` answers on a server with `features`, read as `Transform`. */
+function transformDetailSchema(features) {
+	return features.transformTargetTableId ? Transform : TransformWireV59Detail.transform(fromHydratedTable);
+}
+/** The shape every other transform endpoint answers on a server with `features`, read as `Transform`. */
+function transformRowSchema(features) {
+	return features.transformTargetTableId ? Transform : TransformBase.transform(withoutLink);
+}
+const TransformCompact = Transform.pick({
+	id: true,
+	name: true,
+	description: true,
+	source_type: true,
+	target_db_id: true,
+	target_table_id: true
+}).strip().extend({ target: TransformTargetCompact });
+const TransformCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	source: TransformSource,
+	target: TransformTarget,
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+const TransformUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	source: TransformSource.optional(),
+	target: TransformTarget.optional(),
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+//#endregion
+export { Transform, TransformCompact, TransformCreateInput, TransformDagDirection, TransformDagRunResult, TransformDagTransform, TransformRun, TransformRunCompact, TransformRunMethod, TransformRunResult, TransformRunStatus, TransformRunSummary, TransformRunSummaryCompact, TransformRunSummarySortColumn, TransformRunSummaryType, TransformSourceTableEntry, TransformTarget, TransformUpdateInput, isTransformRunFailed, isTransformRunTerminal, transformDetailSchema, transformRowSchema };

package/dist/domain/upload.d.ts

@@ -0,0 +1,2 @@
+import { n as UploadUpdateAction, r as UploadUpdateResult, t as UploadResult } from "../upload-UPfZFdbH.js";
+export { UploadResult, UploadUpdateAction, UploadUpdateResult };

package/dist/domain/upload.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/domain/upload.ts
+const UploadResult = z.object({
+	model_id: z.number().int(),
+	table_id: z.number().int()
+});
+const UploadUpdateAction = z.enum(["append", "replace"]);
+const UploadUpdateResult = z.object({
+	table_id: z.number().int(),
+	action: UploadUpdateAction
+});
+//#endregion
+export { UploadResult, UploadUpdateAction, UploadUpdateResult };

package/dist/domain/user.d.ts

@@ -0,0 +1,2 @@
+import { n as CurrentUserCompact, t as CurrentUser } from "../user-2r0OBoO6.js";
+export { CurrentUser, CurrentUserCompact };

package/dist/domain/user.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+//#region src/domain/user.ts
+const CurrentUser = z.object({
+	id: z.number().int(),
+	email: z.email(),
+	common_name: z.string(),
+	is_superuser: z.boolean()
+}).loose();
+const CurrentUserCompact = CurrentUser.pick({
+	id: true,
+	email: true,
+	common_name: true,
+	is_superuser: true
+}).strip();
+//#endregion
+export { CurrentUser, CurrentUserCompact };

package/dist/eid-translation-nuhr8St2.d.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+//#region src/domain/eid-translation.d.ts
+declare const EID_MODELS: readonly ["action", "card", "collection", "dashboard", "dashboard-card", "dashboard-tab", "dataset", "dimension", "document", "exploration", "measure", "metric", "permissions-group", "pulse", "pulse-card", "pulse-channel", "segment", "snippet", "timeline", "transform", "user"];
+declare const EidModel: z.ZodEnum<{
+  card: "card";
+  collection: "collection";
+  dashboard: "dashboard";
+  dataset: "dataset";
+  document: "document";
+  metric: "metric";
+  measure: "measure";
+  pulse: "pulse";
+  segment: "segment";
+  snippet: "snippet";
+  timeline: "timeline";
+  transform: "transform";
+  user: "user";
+  dimension: "dimension";
+  exploration: "exploration";
+  action: "action";
+  "dashboard-card": "dashboard-card";
+  "dashboard-tab": "dashboard-tab";
+  "permissions-group": "permissions-group";
+  "pulse-card": "pulse-card";
+  "pulse-channel": "pulse-channel";
+}>;
+type EidModel = z.infer<typeof EidModel>;
+declare const EidTranslateInput: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodEnum<{
+    card: "card";
+    collection: "collection";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    segment: "segment";
+    snippet: "snippet";
+    timeline: "timeline";
+    transform: "transform";
+    user: "user";
+    dimension: "dimension";
+    exploration: "exploration";
+    action: "action";
+    "dashboard-card": "dashboard-card";
+    "dashboard-tab": "dashboard-tab";
+    "permissions-group": "permissions-group";
+    "pulse-card": "pulse-card";
+    "pulse-channel": "pulse-channel";
+  }> & z.core.$partial, z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+type EidTranslateInput = z.infer<typeof EidTranslateInput>;
+declare const EidTranslateEntry: z.ZodObject<{
+  status: z.ZodString;
+  type: z.ZodEnum<{
+    card: "card";
+    collection: "collection";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    segment: "segment";
+    snippet: "snippet";
+    timeline: "timeline";
+    transform: "transform";
+    user: "user";
+    dimension: "dimension";
+    exploration: "exploration";
+    action: "action";
+    "dashboard-card": "dashboard-card";
+    "dashboard-tab": "dashboard-tab";
+    "permissions-group": "permissions-group";
+    "pulse-card": "pulse-card";
+    "pulse-channel": "pulse-channel";
+  }>;
+  id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+type EidTranslateEntry = z.infer<typeof EidTranslateEntry>;
+declare const EidTranslateResult: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodString, z.ZodObject<{
+    status: z.ZodString;
+    type: z.ZodEnum<{
+      card: "card";
+      collection: "collection";
+      dashboard: "dashboard";
+      dataset: "dataset";
+      document: "document";
+      metric: "metric";
+      measure: "measure";
+      pulse: "pulse";
+      segment: "segment";
+      snippet: "snippet";
+      timeline: "timeline";
+      transform: "transform";
+      user: "user";
+      dimension: "dimension";
+      exploration: "exploration";
+      action: "action";
+      "dashboard-card": "dashboard-card";
+      "dashboard-tab": "dashboard-tab";
+      "permissions-group": "permissions-group";
+      "pulse-card": "pulse-card";
+      "pulse-channel": "pulse-channel";
+    }>;
+    id: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+type EidTranslateResult = z.infer<typeof EidTranslateResult>;
+declare const EidTranslateResultCompact: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodString, z.ZodObject<{
+    status: z.ZodString;
+    type: z.ZodEnum<{
+      card: "card";
+      collection: "collection";
+      dashboard: "dashboard";
+      dataset: "dataset";
+      document: "document";
+      metric: "metric";
+      measure: "measure";
+      pulse: "pulse";
+      segment: "segment";
+      snippet: "snippet";
+      timeline: "timeline";
+      transform: "transform";
+      user: "user";
+      dimension: "dimension";
+      exploration: "exploration";
+      action: "action";
+      "dashboard-card": "dashboard-card";
+      "dashboard-tab": "dashboard-tab";
+      "permissions-group": "permissions-group";
+      "pulse-card": "pulse-card";
+      "pulse-channel": "pulse-channel";
+    }>;
+    id: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$strip>;
+type EidTranslateResultCompact = z.infer<typeof EidTranslateResultCompact>;
+//#endregion
+export { EidTranslateResult as a, EidTranslateInput as i, EidModel as n, EidTranslateResultCompact as o, EidTranslateEntry as r, EID_MODELS as t };

package/dist/embedding-Cz3RUJYf.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/domain/embedding.d.ts
+declare const EmbeddingParams: z.ZodRecord<z.ZodString, z.ZodEnum<{
+  disabled: "disabled";
+  enabled: "enabled";
+  locked: "locked";
+}>>;
+type EmbeddingParams = z.infer<typeof EmbeddingParams>;
+//#endregion
+export { EmbeddingParams as t };