@metabase/client 0.0.0-stage → 0.1.1

package/dist/domain/data-action.js

@@ -0,0 +1,91 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { DatasetQuery } from "./query.js";
+import { z } from "zod";
+//#region src/domain/data-action.ts
+const DataActionParameter = z.object({
+	id: z.string(),
+	type: z.string(),
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	target: z.unknown().optional(),
+	required: z.boolean().optional()
+}).loose();
+const DataActionBase = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	type: z.string(),
+	model_id: z.number().int().nullable(),
+	database_id: z.number().int().nullable().optional(),
+	dataset_query: z.unknown().optional(),
+	parameters: z.array(DataActionParameter).nullable(),
+	visualization_settings: z.unknown(),
+	archived: z.boolean(),
+	public_uuid: z.string().nullable(),
+	entity_id: z.string().nullable(),
+	creator_id: z.number().int(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const DataAction = DataActionBase.extend({ collection_id: z.number().int().nullable() });
+function withoutCollection(wire) {
+	return {
+		...wire,
+		collection_id: null
+	};
+}
+/** The shape every data action endpoint answers on a server with `features`, read as `DataAction`. */
+function dataActionSchema(features) {
+	return features.dataActionCollections ? DataAction : DataActionBase.transform(withoutCollection);
+}
+const DataActionCompact = DataAction.pick({
+	id: true,
+	name: true,
+	type: true,
+	collection_id: true,
+	database_id: true,
+	archived: true
+}).strip();
+const DataActionParameterInput = z.object({
+	id: z.string().min(1),
+	type: z.string().min(1),
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	target: z.unknown(),
+	required: z.boolean().optional()
+}).loose();
+const DataActionCreateInput = z.object({
+	name: z.string().min(1),
+	type: z.literal("query"),
+	database_id: z.number().int().positive(),
+	dataset_query: DatasetQuery,
+	parameters: z.array(DataActionParameterInput).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	description: z.string().nullable().optional(),
+	visualization_settings: z.unknown().optional()
+}).strict();
+const DATA_ACTION_COLLECTION_GATE = {
+	feature: "dataActionCollections",
+	effect: "needs",
+	when: { kind: "present" }
+};
+const DataActionUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	database_id: z.number().int().positive().optional(),
+	dataset_query: DatasetQuery.optional(),
+	parameters: z.array(DataActionParameterInput).optional(),
+	collection_id: gateInput(z.number().int().positive().nullable().optional(), DATA_ACTION_COLLECTION_GATE),
+	description: z.string().nullable().optional(),
+	visualization_settings: z.unknown().optional(),
+	archived: z.boolean().optional()
+}).strict();
+const DataActionParameterValue = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const DataActionExecuteInput = z.object({ parameters: z.record(z.string(), DataActionParameterValue) }).strict();
+const DataActionExecuteResult = z.object({ "rows-affected": z.number().int() }).loose();
+//#endregion
+export { DATA_ACTION_COLLECTION_GATE, DataAction, DataActionCompact, DataActionCreateInput, DataActionExecuteInput, DataActionExecuteResult, DataActionParameter, DataActionUpdateInput, dataActionSchema };

package/dist/domain/data-app.d.ts

@@ -0,0 +1,2 @@
+import { a as DataAppListFilter, c as DataAppUpdateInput, i as DataAppEntry, n as DataAppCompact, o as DataAppSlug, r as DataAppCreateInput, s as DataAppSummary, t as DataApp } from "../data-app-CqP5_fpB.js";
+export { DataApp, DataAppCompact, DataAppCreateInput, DataAppEntry, DataAppListFilter, DataAppSlug, DataAppSummary, DataAppUpdateInput };

package/dist/domain/data-app.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+//#region src/domain/data-app.ts
+const DATA_APP_SLUG_MAX_LENGTH = 100;
+const RESERVED_DATA_APP_SLUGS = /* @__PURE__ */ new Set(["repo-status", "sandbox-host"]);
+const DataAppSlug = z.string().max(DATA_APP_SLUG_MAX_LENGTH, `must be at most ${DATA_APP_SLUG_MAX_LENGTH} characters`).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be dash-cased: a-z, 0-9 and single dashes").refine((slug) => !RESERVED_DATA_APP_SLUGS.has(slug), "is reserved by Metabase");
+const DataApp = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	version: z.number().int(),
+	outdated: z.boolean(),
+	bundle_path: z.string(),
+	enabled: z.boolean(),
+	allowed_hosts: z.array(z.string()),
+	resource_collection_id: z.number().int(),
+	bundle_hash: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const DataAppSummary = z.object({
+	name: z.string(),
+	display_name: z.string()
+}).strict();
+const DataAppEntry = z.union([DataApp, DataAppSummary]);
+const DataAppCompact = DataApp.pick({
+	name: true,
+	display_name: true,
+	enabled: true,
+	resource_collection_id: true,
+	outdated: true
+}).strip().partial({
+	enabled: true,
+	resource_collection_id: true,
+	outdated: true
+});
+const DataAppListFilter = z.object({ available: z.boolean().optional() }).strict();
+const DataAppFields = {
+	display_name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	version: z.number().int().positive().optional(),
+	bundle_path: z.string().min(1).optional(),
+	allowed_hosts: z.array(z.string()).optional(),
+	enabled: z.boolean().optional()
+};
+const DataAppCreateInput = z.object({
+	name: DataAppSlug,
+	...DataAppFields
+}).strict();
+const DataAppUpdateInput = z.object(DataAppFields).strict();
+//#endregion
+export { DataApp, DataAppCompact, DataAppCreateInput, DataAppEntry, DataAppListFilter, DataAppSlug, DataAppSummary, DataAppUpdateInput };

package/dist/domain/database.d.ts

@@ -0,0 +1,2 @@
+import { a as DatabaseSettings, c as DatabaseVirtualTable, d as DatabaseWithSettingsCompact, i as DatabaseListInclude, l as DatabaseVirtualTableCompact, n as DatabaseCompact, o as DatabaseSyncResult, r as DatabaseGetInclude, s as DatabaseUpdateInput, t as Database, u as DatabaseWithSettings } from "../database-BxqDmfcj.js";
+export { Database, DatabaseCompact, DatabaseGetInclude, DatabaseListInclude, DatabaseSettings, DatabaseSyncResult, DatabaseUpdateInput, DatabaseVirtualTable, DatabaseVirtualTableCompact, DatabaseWithSettings, DatabaseWithSettingsCompact };

package/dist/domain/database.js

@@ -0,0 +1,56 @@
+import { CardType } from "./card.js";
+import { Table, TableCompact } from "./table.js";
+import { z } from "zod";
+//#region src/domain/database.ts
+const DatabaseVirtualTable = z.object({
+	id: z.string(),
+	db_id: z.number().int(),
+	display_name: z.string(),
+	schema: z.string(),
+	description: z.string().nullable(),
+	type: CardType,
+	moderated_status: z.string().nullable(),
+	entity_id: z.string().nullable()
+}).loose();
+const DatabaseVirtualTableCompact = DatabaseVirtualTable.pick({
+	id: true,
+	db_id: true,
+	display_name: true,
+	schema: true,
+	description: true,
+	type: true
+}).strip();
+const Database = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	engine: z.string().optional(),
+	is_saved_questions: z.boolean().optional(),
+	is_sample: z.boolean().optional(),
+	is_audit: z.boolean().optional(),
+	initial_sync_status: z.string().nullable().optional(),
+	tables: z.array(z.union([Table, DatabaseVirtualTable])).optional()
+}).loose();
+const DatabaseCompact = Database.pick({
+	id: true,
+	name: true,
+	engine: true,
+	is_saved_questions: true
+}).strip().extend({ tables: z.array(z.union([TableCompact, DatabaseVirtualTableCompact])).optional() });
+const DatabaseListInclude = z.enum(["tables"]);
+const DatabaseGetInclude = z.enum(["tables", "tables.fields"]);
+const DATA_ACTIONS_SETTING = "database-enable-actions";
+const DatabaseSettings = z.object({ [DATA_ACTIONS_SETTING]: z.boolean().optional() }).loose();
+const DatabaseWithSettings = Database.extend({ settings: DatabaseSettings.nullable() });
+const DatabaseWithSettingsCompact = DatabaseWithSettings.pick({
+	id: true,
+	name: true,
+	engine: true
+}).strip().extend({ settings: DatabaseSettings.pick({ [DATA_ACTIONS_SETTING]: true }).strip().nullable() });
+const DatabaseUpdateInput = z.object({ settings: z.object({ [DATA_ACTIONS_SETTING]: z.boolean() }).strict() }).strict();
+const DatabaseSyncResult = z.object({
+	id: z.number().int(),
+	status: z.literal("ok"),
+	initial_sync_status: z.string().nullable().optional()
+});
+//#endregion
+export { Database, DatabaseCompact, DatabaseGetInclude, DatabaseListInclude, DatabaseSettings, DatabaseSyncResult, DatabaseUpdateInput, DatabaseVirtualTable, DatabaseVirtualTableCompact, DatabaseWithSettings, DatabaseWithSettingsCompact };

package/dist/domain/dataset.d.ts

@@ -0,0 +1,2 @@
+import { a as QueryMetadataTable, c as VirtualTable, i as QueryMetadataCompact, l as VirtualTableCompact, n as CompiledQueryCompact, o as VirtualField, r as QueryMetadata, s as VirtualFieldCompact, t as CompiledQuery } from "../dataset-BBNGPVec.js";
+export { CompiledQuery, CompiledQueryCompact, QueryMetadata, QueryMetadataCompact, QueryMetadataTable, VirtualField, VirtualFieldCompact, VirtualTable, VirtualTableCompact };

package/dist/domain/dataset.js

@@ -0,0 +1,56 @@
+import { Field, FieldBaseType, FieldCompact, FieldSemanticType } from "./field.js";
+import { TableQueryMetadata, TableQueryMetadataCompact } from "./table.js";
+import { Database, DatabaseCompact, DatabaseVirtualTable, DatabaseVirtualTableCompact } from "./database.js";
+import { Snippet, SnippetCompact } from "./snippet.js";
+import { z } from "zod";
+//#region src/domain/dataset.ts
+const CompiledQuery = z.object({
+	query: z.union([z.string(), z.array(z.unknown())]),
+	params: z.array(z.unknown()).nullable().optional(),
+	collection: z.string().nullable().optional()
+}).loose();
+const CompiledQueryCompact = CompiledQuery.pick({
+	query: true,
+	params: true,
+	collection: true
+}).strip();
+const FieldRef = z.tuple([
+	z.literal("field"),
+	z.string(),
+	z.object({ "base-type": FieldBaseType }).loose()
+]);
+const VirtualField = z.object({
+	id: z.union([z.number().int(), FieldRef]),
+	table_id: z.string(),
+	name: z.string(),
+	display_name: z.string(),
+	base_type: FieldBaseType,
+	semantic_type: FieldSemanticType.nullable(),
+	fk_target_field_id: z.number().int().nullable().optional()
+}).loose();
+const VirtualFieldCompact = VirtualField.pick({
+	id: true,
+	table_id: true,
+	name: true,
+	display_name: true,
+	base_type: true,
+	semantic_type: true,
+	fk_target_field_id: true
+}).strip();
+const VirtualTable = DatabaseVirtualTable.extend({ fields: z.array(VirtualField) });
+const VirtualTableCompact = DatabaseVirtualTableCompact.extend({ fields: z.array(VirtualFieldCompact) });
+const QueryMetadataTable = TableQueryMetadata.omit({ db: true });
+const QueryMetadata = z.object({
+	databases: z.array(Database),
+	tables: z.array(z.union([QueryMetadataTable, VirtualTable])),
+	fields: z.array(Field),
+	snippets: z.array(Snippet)
+}).loose();
+const QueryMetadataCompact = z.object({
+	databases: z.array(DatabaseCompact),
+	tables: z.array(z.union([TableQueryMetadataCompact, VirtualTableCompact])),
+	fields: z.array(FieldCompact),
+	snippets: z.array(SnippetCompact)
+});
+//#endregion
+export { CompiledQuery, CompiledQueryCompact, QueryMetadata, QueryMetadataCompact, QueryMetadataTable, VirtualField, VirtualFieldCompact, VirtualTable, VirtualTableCompact };

package/dist/domain/dependency.d.ts

@@ -0,0 +1,2 @@
+import { _ as DependentsSortColumn, a as DependencyEntityCompact, c as DependencyFindingError, d as DependencyGraphCompact, f as DependencyItemsSortColumn, g as DependencyUsageType, h as DependencyType, i as DependencyEntity, l as DependencyFindingErrorType, m as DependencyNodeCompact, n as BreakingSourceCompact, o as DependencyEntityData, p as DependencyNode, r as DependencyEdge, s as DependencyErrorSourceType, t as BreakingSource, u as DependencyGraph } from "../dependency-arB8Cr2H.js";
+export { BreakingSource, BreakingSourceCompact, DependencyEdge, DependencyEntity, DependencyEntityCompact, DependencyEntityData, DependencyErrorSourceType, DependencyFindingError, DependencyFindingErrorType, DependencyGraph, DependencyGraphCompact, DependencyItemsSortColumn, DependencyNode, DependencyNodeCompact, DependencyType, DependencyUsageType, DependentsSortColumn };

package/dist/domain/dependency.js

@@ -0,0 +1,168 @@
+import { CardType } from "./card.js";
+import { CollectionAuthorityLevel, CollectionId } from "./collection.js";
+import { z } from "zod";
+//#region src/domain/dependency.ts
+const DependencyType = z.enum([
+	"table",
+	"card",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"measure",
+	"action"
+]);
+const DependencyUsageType = z.enum([
+	"table",
+	"snippet",
+	"transform",
+	"dashboard",
+	"document",
+	"sandbox",
+	"segment",
+	"question",
+	"model",
+	"metric",
+	"measure",
+	"action"
+]);
+const DependencyFindingErrorType = z.enum([
+	"missing-column",
+	"missing-table-alias",
+	"missing-table",
+	"missing-card",
+	"duplicate-column",
+	"syntax-error",
+	"validation-exception-error"
+]);
+const DependencyErrorSourceType = z.enum([
+	"table",
+	"card",
+	"transform"
+]);
+const DependentsSortColumn = z.enum([
+	"name",
+	"location",
+	"view-count"
+]);
+const DependencyItemsSortColumn = z.enum([
+	"name",
+	"location",
+	"dependents-with-errors",
+	"dependents-errors"
+]);
+const DependencyCollectionRef = z.object({
+	id: CollectionId,
+	name: z.string(),
+	authority_level: CollectionAuthorityLevel.nullable(),
+	is_personal: z.boolean().optional()
+}).loose();
+const DependencyContainerRef = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const DependencyDatabaseRef = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const DependencyTableRef = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string()
+}).loose();
+const DependencyActionType = z.enum(["implicit", "query"]);
+const DependencyEntityData = z.object({
+	name: z.string().nullable().optional(),
+	display_name: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	type: z.union([CardType, DependencyActionType]).nullable().optional(),
+	display: z.string().nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	db_id: z.number().int().nullable().optional(),
+	schema: z.string().nullable().optional(),
+	collection_id: CollectionId.nullable().optional(),
+	collection: DependencyCollectionRef.nullable().optional(),
+	dashboard_id: z.number().int().nullable().optional(),
+	dashboard: DependencyContainerRef.nullable().optional(),
+	document_id: z.number().int().nullable().optional(),
+	document: DependencyContainerRef.nullable().optional(),
+	db: DependencyDatabaseRef.nullable().optional(),
+	table_id: z.number().int().nullable().optional(),
+	table: DependencyTableRef.nullable().optional(),
+	view_count: z.number().int().nullable().optional()
+}).loose();
+const DependencyEntity = z.object({
+	id: z.number().int(),
+	type: DependencyType,
+	data: DependencyEntityData
+}).loose();
+const DependencyEntityDataCompact = DependencyEntityData.pick({
+	name: true,
+	display_name: true,
+	description: true,
+	type: true,
+	database_id: true,
+	db_id: true,
+	schema: true,
+	table_id: true,
+	collection_id: true,
+	dashboard_id: true,
+	document_id: true,
+	view_count: true
+}).strip().extend({
+	db: DependencyDatabaseRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional(),
+	table: DependencyTableRef.pick({
+		id: true,
+		name: true,
+		display_name: true
+	}).strip().nullable().optional(),
+	collection: DependencyCollectionRef.pick({
+		id: true,
+		name: true,
+		authority_level: true,
+		is_personal: true
+	}).strip().nullable().optional(),
+	dashboard: DependencyContainerRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional(),
+	document: DependencyContainerRef.pick({
+		id: true,
+		name: true
+	}).strip().nullable().optional()
+});
+const DependencyEntityCompact = DependencyEntity.pick({
+	id: true,
+	type: true
+}).strip().extend({ data: DependencyEntityDataCompact });
+const DependencyNode = DependencyEntity.extend({ dependents_count: z.partialRecord(DependencyUsageType, z.number().int()).nullable() });
+const DependencyNodeCompact = DependencyEntityCompact.extend({ dependents_count: DependencyNode.shape.dependents_count });
+const DependencyFindingError = z.object({
+	id: z.number().int(),
+	analyzed_entity_type: DependencyType,
+	analyzed_entity_id: z.number().int(),
+	error_type: DependencyFindingErrorType,
+	error_detail: z.string().nullable().optional(),
+	source_entity_type: DependencyErrorSourceType.nullable().optional(),
+	source_entity_id: z.number().int().nullable().optional()
+}).loose();
+const BreakingSource = DependencyNode.extend({ dependents_errors: z.array(DependencyFindingError).nullable().optional() });
+const BreakingSourceCompact = DependencyNodeCompact.extend({ dependents_errors: BreakingSource.shape.dependents_errors });
+const DependencyEdge = z.object({
+	from_entity_type: DependencyType,
+	from_entity_id: z.number().int(),
+	to_entity_type: DependencyType,
+	to_entity_id: z.number().int()
+}).loose();
+const DependencyGraph = z.object({
+	nodes: z.array(DependencyNode),
+	edges: z.array(DependencyEdge)
+}).loose();
+const DependencyGraphCompact = DependencyGraph.pick({ edges: true }).strip().extend({ nodes: z.array(DependencyNodeCompact) });
+//#endregion
+export { BreakingSource, BreakingSourceCompact, DependencyEdge, DependencyEntity, DependencyEntityCompact, DependencyEntityData, DependencyErrorSourceType, DependencyFindingError, DependencyFindingErrorType, DependencyGraph, DependencyGraphCompact, DependencyItemsSortColumn, DependencyNode, DependencyNodeCompact, DependencyType, DependencyUsageType, DependentsSortColumn };

package/dist/domain/document.d.ts

@@ -0,0 +1,2 @@
+import { a as DocumentUpdateInput, i as DocumentCreateInput, n as DocumentCompact, o as TipTapNode, r as DocumentCopyInput, s as TipTapNodeInput, t as Document } from "../document-tLd6pYWe.js";
+export { Document, DocumentCompact, DocumentCopyInput, DocumentCreateInput, DocumentUpdateInput, TipTapNode, TipTapNodeInput };

package/dist/domain/document.js

@@ -0,0 +1,94 @@
+import { NonBlankText } from "./text.js";
+import { z } from "zod";
+//#region src/domain/document.ts
+const TipTapNode = z.looseObject({
+	type: z.string(),
+	text: z.string().optional(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	marks: z.array(z.record(z.string(), z.unknown())).optional(),
+	get content() {
+		return z.array(TipTapNode).optional();
+	}
+});
+const NODE_TYPES_WITH_ID = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"codeBlock",
+	"orderedList",
+	"bulletList",
+	"blockquote",
+	"cardEmbed",
+	"supportingText"
+]);
+function validateNodeId({ type, attrs, content = [] }) {
+	const id = attrs?.["_id"];
+	if (NODE_TYPES_WITH_ID.has(type) && (typeof id !== "string" || id === "")) return false;
+	return content.every(validateNodeId);
+}
+const TipTapNodeInput = TipTapNode.refine(validateNodeId, { message: `every ${[...NODE_TYPES_WITH_ID].join(", ")} node needs a non-empty string \`_id\`` });
+const DocumentCreator = z.object({
+	id: z.number().int(),
+	email: z.string(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable()
+}).loose();
+const Document = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	document: TipTapNode.nullable(),
+	entity_id: z.string().nullable(),
+	collection_id: z.number().int().nullable(),
+	collection_position: z.number().int().nullable().optional(),
+	creator_id: z.number().int(),
+	creator: DocumentCreator.nullable().optional(),
+	archived: z.boolean(),
+	can_write: z.boolean().optional(),
+	can_delete: z.boolean().optional(),
+	can_restore: z.boolean().optional(),
+	is_remote_synced: z.boolean().optional(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const DocumentCompact = Document.pick({
+	id: true,
+	name: true,
+	collection_id: true,
+	archived: true,
+	creator_id: true,
+	can_write: true
+}).strip();
+const DocumentName = z.string().min(1).max(254);
+const DocumentCardInput = z.object({
+	name: z.string().min(1),
+	dataset_query: z.record(z.string(), z.unknown()),
+	display: z.string().min(1),
+	visualization_settings: z.record(z.string(), z.unknown()),
+	entity_id: z.string().min(1).nullable().optional(),
+	parameters: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
+	parameter_mappings: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
+	description: z.string().min(1).nullable().optional(),
+	result_metadata: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
+	cache_ttl: z.number().int().positive().nullable().optional()
+}).loose();
+const DocumentCreateInput = z.object({
+	name: DocumentName,
+	document: TipTapNodeInput,
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	cards: z.record(z.string().regex(/^-\d+$/), DocumentCardInput).nullable().optional().describe("cards to create inline, keyed by the negative placeholder id referenced from cardEmbed nodes")
+}).loose();
+const DocumentUpdateInput = z.object({
+	name: DocumentName.optional(),
+	document: TipTapNodeInput.optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	archived: z.boolean().nullable().optional(),
+	cards: z.record(z.string().regex(/^-?\d+$/), DocumentCardInput).nullable().optional().describe("cards keyed by card id; negative ids create new cards")
+}).loose();
+const DocumentCopyInput = z.object({
+	name: NonBlankText.nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional()
+}).strict();
+//#endregion
+export { Document, DocumentCompact, DocumentCopyInput, DocumentCreateInput, DocumentUpdateInput, TipTapNode, TipTapNodeInput };

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

@@ -0,0 +1,2 @@
+import { a as EidTranslateResult, i as EidTranslateInput, n as EidModel, o as EidTranslateResultCompact, r as EidTranslateEntry, t as EID_MODELS } from "../eid-translation-CH6NPWd-.js";
+export { EID_MODELS, EidModel, EidTranslateEntry, EidTranslateInput, EidTranslateResult, EidTranslateResultCompact };

package/dist/domain/eid-translation.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+//#region src/domain/eid-translation.ts
+const EID_MODELS = [
+	"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"
+];
+const EidModel = z.enum(EID_MODELS);
+const EidTranslateInput = z.object({ entity_ids: z.partialRecord(EidModel, z.array(z.string().length(21))) }).loose();
+const EidTranslateEntry = z.object({
+	status: z.string(),
+	type: EidModel,
+	id: z.number().int().optional()
+}).loose();
+const EidTranslateResult = z.object({ entity_ids: z.record(z.string(), EidTranslateEntry) }).loose();
+const EidTranslateResultCompact = EidTranslateResult.pick({ entity_ids: true }).strip();
+//#endregion
+export { EID_MODELS, EidModel, EidTranslateEntry, EidTranslateInput, EidTranslateResult, EidTranslateResultCompact };

package/dist/domain/embedding.d.ts

@@ -0,0 +1,2 @@
+import { t as EmbeddingParams } from "../embedding-oU3gqfgX.js";
+export { EmbeddingParams };

package/dist/domain/embedding.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+//#region src/domain/embedding.ts
+const EmbeddingParams = z.record(z.string(), z.enum([
+	"disabled",
+	"enabled",
+	"locked"
+]));
+//#endregion
+export { EmbeddingParams };

package/dist/domain/erd.d.ts

@@ -0,0 +1,2 @@
+import { i as ErdNode, n as ErdEdge, r as ErdField, t as Erd } from "../erd-BdeFEeSy.js";
+export { Erd, ErdEdge, ErdField, ErdNode };

package/dist/domain/erd.js

@@ -0,0 +1,45 @@
+import { FieldBaseType, FieldSemanticType } from "./field.js";
+import { TableVisibilityType } from "./table.js";
+import { z } from "zod";
+//#region src/domain/erd.ts
+const ErdField = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	database_type: z.string(),
+	base_type: FieldBaseType.nullable(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable(),
+	fk_target_field_id: z.number().int().nullable(),
+	fk_target_table_id: z.number().int().nullable()
+}).loose();
+const ErdOwner = z.object({
+	id: z.number().int().optional(),
+	email: z.string(),
+	first_name: z.string().nullable().optional(),
+	last_name: z.string().nullable().optional()
+}).loose().nullable();
+const ErdNode = z.object({
+	table_id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	owner: ErdOwner,
+	schema: z.string().nullable(),
+	visibility_type: TableVisibilityType.nullable(),
+	db_id: z.number().int(),
+	fields: z.array(ErdField)
+}).loose();
+const ErdEdge = z.object({
+	source_table_id: z.number().int(),
+	source_field_id: z.number().int(),
+	target_table_id: z.number().int(),
+	target_field_id: z.number().int(),
+	relationship: z.enum(["one-to-one", "many-to-one"])
+}).loose();
+const Erd = z.object({
+	nodes: z.array(ErdNode),
+	edges: z.array(ErdEdge)
+}).loose();
+//#endregion
+export { Erd, ErdEdge, ErdField, ErdNode };

package/dist/domain/field.d.ts

@@ -0,0 +1,2 @@
+import { _ as FieldWithTarget, a as FieldCompact, b as hasDataSensitivity, c as FieldRemappedValue, d as FieldSummary, f as FieldUpdateInput, g as FieldWithDataSensitivityCompact, h as FieldWithDataSensitivity, i as FieldCoercionStrategy, l as FieldSearchMatches, m as FieldValuesCompact, n as Field, o as FieldDataSensitivity, p as FieldValues, r as FieldBaseType, s as FieldDetail, t as DATA_SENSITIVITY_GATE, u as FieldSemanticType, v as fieldDetailSchema, y as fieldRemappedValueSchema } from "../field-p9Rme2zB.js";
+export { DATA_SENSITIVITY_GATE, Field, FieldBaseType, FieldCoercionStrategy, FieldCompact, FieldDataSensitivity, FieldDetail, FieldRemappedValue, FieldSearchMatches, FieldSemanticType, FieldSummary, FieldUpdateInput, FieldValues, FieldValuesCompact, FieldWithDataSensitivity, FieldWithDataSensitivityCompact, FieldWithTarget, fieldDetailSchema, fieldRemappedValueSchema, hasDataSensitivity };