@metabase/client 0.0.0-stage → 0.1.0

package/dist/domain/collection.js

@@ -0,0 +1,137 @@
+import { NonBlankText } from "./text.js";
+import { z } from "zod";
+//#region src/domain/collection.ts
+const CollectionId = z.union([z.number().int(), z.string()]);
+const CollectionAuthorityLevel = z.enum(["official"]);
+const CollectionType = z.enum([
+	"instance-analytics",
+	"trash",
+	"library",
+	"library-data",
+	"library-metrics",
+	"library-dashboards",
+	"tenant-specific-root-collection"
+]);
+const CollectionNamespace = z.enum([
+	"transforms",
+	"snippets",
+	"analytics",
+	"shared-tenant-collection",
+	"tenant-specific",
+	"data-apps",
+	"data-actions"
+]);
+const CollectionListFilter = z.enum([
+	"all",
+	"archived",
+	"personal"
+]);
+const COLLECTION_ITEM_FILTER_MODELS = [
+	"card",
+	"dataset",
+	"metric",
+	"dashboard",
+	"snippet",
+	"collection",
+	"document",
+	"exploration",
+	"table",
+	"transform",
+	"measure",
+	"pulse",
+	"timeline",
+	"no_models"
+];
+const CollectionItemFilterModel = z.enum(COLLECTION_ITEM_FILTER_MODELS);
+const COLLECTION_ITEM_MODELS = [
+	...COLLECTION_ITEM_FILTER_MODELS,
+	"indexed-entity",
+	"action"
+];
+const CollectionItemModel = z.enum(COLLECTION_ITEM_MODELS);
+const COLLECTION_PINNED_STATES = [
+	"all",
+	"is_pinned",
+	"is_not_pinned"
+];
+const CollectionPinnedState = z.enum(COLLECTION_PINNED_STATES);
+const Collection = z.object({
+	id: CollectionId,
+	name: z.string(),
+	description: z.string().nullable().optional(),
+	archived: z.boolean().optional(),
+	location: z.string().nullable().optional(),
+	parent_id: CollectionId.nullable().optional(),
+	personal_owner_id: z.number().int().nullable().optional(),
+	is_personal: z.boolean().optional(),
+	authority_level: CollectionAuthorityLevel.nullable().optional(),
+	type: CollectionType.nullable().optional(),
+	namespace: CollectionNamespace.nullable().optional(),
+	entity_id: z.string().nullable().optional(),
+	slug: z.string().optional(),
+	can_write: z.boolean().optional(),
+	is_remote_synced: z.boolean().nullable().optional()
+}).loose();
+const CollectionCompact = Collection.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	location: true,
+	parent_id: true,
+	type: true,
+	namespace: true,
+	authority_level: true,
+	is_personal: true,
+	is_remote_synced: true
+}).strip();
+const CollectionItem = z.object({
+	id: z.number().int(),
+	model: CollectionItemModel,
+	name: z.string(),
+	description: z.string().nullable().optional(),
+	archived: z.boolean().nullable(),
+	collection_id: CollectionId.nullable().optional(),
+	collection_position: z.number().int().nullable().optional(),
+	display: z.string().nullable().optional(),
+	location: z.string().nullable().optional(),
+	entity_id: z.string().nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	dashboard_id: z.number().int().nullable().optional()
+}).loose();
+const CollectionItemCompact = CollectionItem.pick({
+	id: true,
+	model: true,
+	name: true,
+	description: true,
+	archived: true,
+	collection_id: true
+}).strip();
+const CollectionTreeNode = z.object({
+	id: CollectionId,
+	name: z.string(),
+	description: z.string().nullable().optional(),
+	archived: z.boolean().optional(),
+	location: z.string().nullable().optional(),
+	type: CollectionType.nullable().optional(),
+	authority_level: CollectionAuthorityLevel.nullable().optional(),
+	here: z.array(CollectionItemModel).optional(),
+	below: z.array(CollectionItemModel).optional()
+}).loose().extend({ children: z.lazy(() => z.array(CollectionTreeNode)) });
+const CollectionCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().min(1).nullable().optional(),
+	parent_id: z.number().int().positive().nullable().optional(),
+	namespace: CollectionNamespace.nullable().optional(),
+	authority_level: CollectionAuthorityLevel.nullable().optional()
+}).loose();
+const CollectionUpdateFields = z.object({
+	name: NonBlankText.optional(),
+	description: NonBlankText.nullable().optional(),
+	parent_id: z.number().int().positive().nullable().optional(),
+	authority_level: CollectionAuthorityLevel.nullable().optional(),
+	archived: z.boolean().optional()
+}).strict();
+const CollectionUpdateInput = CollectionUpdateFields.refine((patch) => Object.keys(patch).length > 0, `the patch is empty: give at least one of ${Object.keys(CollectionUpdateFields.shape).join(", ")}`);
+//#endregion
+export { COLLECTION_ITEM_FILTER_MODELS, COLLECTION_ITEM_MODELS, COLLECTION_PINNED_STATES, Collection, CollectionAuthorityLevel, CollectionCompact, CollectionCreateInput, CollectionId, CollectionItem, CollectionItemCompact, CollectionItemFilterModel, CollectionItemModel, CollectionListFilter, CollectionNamespace, CollectionPinnedState, CollectionTreeNode, CollectionType, CollectionUpdateInput };

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

@@ -0,0 +1,2 @@
+import { t as ContentTranslationUploadResult } from "../content-translation-zfUkE_OG.js";
+export { ContentTranslationUploadResult };

package/dist/domain/content-translation.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/domain/content-translation.ts
+const ContentTranslationUploadResult = z.object({ success: z.literal(true) });
+//#endregion
+export { ContentTranslationUploadResult };

package/dist/domain/cron.d.ts

@@ -0,0 +1,2 @@
+import { t as CronUiDisplayType } from "../cron-DThzerR6.js";
+export { CronUiDisplayType };

package/dist/domain/cron.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/domain/cron.ts
+const CronUiDisplayType = z.enum(["cron/raw", "cron/builder"]);
+//#endregion
+export { CronUiDisplayType };

package/dist/domain/dashboard.d.ts

@@ -0,0 +1,2 @@
+import { _ as DashcardPatchInput, a as DashboardCopyInput, b as UnreadableCard, c as DashboardListFilter, d as DashboardTabCompact, f as DashboardUncopiedCard, g as DashcardDetail, h as DashcardCompact, i as DashboardCopyCompact, l as DashboardParameterConstraints, m as Dashcard, n as DashboardCompact, o as DashboardCreateInput, p as DashboardUpdateInput, r as DashboardCopy, s as DashboardDetail, t as Dashboard, u as DashboardTab, v as DashcardVirtualCard, y as DashcardVisualizationSettings } from "../dashboard-z9i1VUZC.js";
+export { Dashboard, DashboardCompact, DashboardCopy, DashboardCopyCompact, DashboardCopyInput, DashboardCreateInput, DashboardDetail, DashboardListFilter, DashboardParameterConstraints, DashboardTab, DashboardTabCompact, DashboardUncopiedCard, DashboardUpdateInput, Dashcard, DashcardCompact, DashcardDetail, DashcardPatchInput, DashcardVirtualCard, DashcardVisualizationSettings, UnreadableCard };

package/dist/domain/dashboard.js

@@ -0,0 +1,194 @@
+import { EmbeddingParams } from "./embedding.js";
+import { Parameter, ParameterMapping } from "./parameter.js";
+import { Card } from "./card.js";
+import { z } from "zod";
+//#region src/domain/dashboard.ts
+const DashboardWidth = z.enum(["fixed", "full"]);
+const DashboardListFilter = z.enum([
+	"all",
+	"mine",
+	"archived"
+]);
+const Dashcard = z.object({
+	id: z.number().int(),
+	dashboard_id: z.number().int(),
+	card_id: z.number().int().nullable(),
+	dashboard_tab_id: z.number().int().nullable(),
+	row: z.number().int(),
+	col: z.number().int(),
+	size_x: z.number().int(),
+	size_y: z.number().int(),
+	entity_id: z.string().nullable(),
+	visualization_settings: z.unknown(),
+	parameter_mappings: z.array(ParameterMapping).nullable(),
+	inline_parameters: z.array(z.string()).nullable()
+}).loose();
+const DashcardCompact = Dashcard.pick({
+	id: true,
+	dashboard_id: true,
+	card_id: true,
+	dashboard_tab_id: true,
+	row: true,
+	col: true,
+	size_x: true,
+	size_y: true,
+	parameter_mappings: true
+}).strip();
+/**
+* What a dashcard that is not a chart of a card shows. `display` names it: `text`, `heading`,
+* `link`, `iframe`, `placeholder`, or `action` for an action button. The server stores the
+* settings without checking them, so `display` is an open string another client may leave out.
+*/
+const DashcardVirtualCard = z.object({ display: z.string().optional() }).loose();
+/**
+* A dashcard's visualization settings. Every key is free-form except the two that say what a
+* dashcard is when it is not a chart: `virtual_card`, and `text`, the Markdown a text or heading
+* dashcard shows.
+*/
+const DashcardVisualizationSettings = z.object({
+	virtual_card: DashcardVirtualCard.nullable().optional(),
+	text: z.string().nullable().optional()
+}).loose();
+/**
+* A card the caller cannot read. The server cuts it down to its `id` before answering, so a
+* dashboard the caller can read still lists it; a readable card always carries its `name`, which is
+* what tells the two apart.
+*/
+const UnreadableCard = z.object({
+	id: z.number().int(),
+	name: z.never().optional()
+}).loose();
+/**
+* A dashcard as a dashboard read or write returns it, with its card whole in `card`. An action
+* button bound to a model carries the model there and the action in `action_id`. A dashcard bound to
+* no card (a text, heading, link, iframe or placeholder dashcard, or an action button bound to no
+* model, which `visualization_settings.virtual_card` names) has `card_id` and `card` both `null`.
+*/
+const DashcardDetail = Dashcard.extend({
+	action_id: z.number().int().nullable(),
+	visualization_settings: DashcardVisualizationSettings,
+	card: z.union([Card, UnreadableCard]).nullable()
+});
+const DashboardTab = z.object({
+	id: z.number().int(),
+	dashboard_id: z.number().int(),
+	name: z.string(),
+	position: z.number().int().optional(),
+	entity_id: z.string().nullable().optional()
+}).loose();
+const DashboardTabCompact = DashboardTab.pick({
+	id: true,
+	dashboard_id: true,
+	name: true,
+	position: true
+}).strip();
+const Dashboard = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	archived: z.boolean(),
+	collection_id: z.number().int().nullable(),
+	creator_id: z.number().int(),
+	entity_id: z.string().nullable(),
+	width: DashboardWidth,
+	auto_apply_filters: z.boolean(),
+	enable_embedding: z.boolean(),
+	public_uuid: z.string().nullable(),
+	cache_ttl: z.number().int().nullable(),
+	collection_position: z.number().int().nullable(),
+	parameters: z.array(Parameter).nullable(),
+	dashcards: z.array(Dashcard).optional(),
+	tabs: z.array(DashboardTab).optional()
+}).loose();
+const DashboardDetail = Dashboard.extend({
+	parameters: z.array(Parameter),
+	dashcards: z.array(DashcardDetail),
+	tabs: z.array(DashboardTab)
+});
+const DashboardCompact = Dashboard.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	collection_id: true
+}).strip().extend({
+	dashcards: z.array(DashcardCompact).optional(),
+	tabs: z.array(DashboardTabCompact).optional()
+});
+const DashcardWrite = z.object({
+	id: z.number().int().describe("existing dashcard id; negative to create a new dashcard"),
+	card_id: z.number().int().positive().nullable().describe("card the dashcard renders; null for a virtual (text, heading, link) or action dashcard"),
+	size_x: z.number().int().positive(),
+	size_y: z.number().int().positive(),
+	row: z.number().int().nonnegative(),
+	col: z.number().int().nonnegative(),
+	parameter_mappings: z.array(ParameterMapping).nullable().optional(),
+	inline_parameters: z.array(z.string().min(1)).nullable().optional(),
+	series: z.array(z.record(z.string(), z.unknown())).nullable().optional()
+}).loose();
+const DashboardTabWrite = z.object({
+	id: z.number().int().describe("existing tab id; negative to create a new tab"),
+	name: z.string().min(1)
+}).loose();
+const DashboardCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	parameters: z.array(Parameter).nullable().optional(),
+	cache_ttl: z.number().int().positive().nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	dashcards: z.array(DashcardWrite).optional(),
+	tabs: z.array(DashboardTabWrite).optional()
+}).loose();
+const DashboardUpdateInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	description: z.string().nullable().optional(),
+	caveats: z.string().nullable().optional(),
+	points_of_interest: z.string().nullable().optional(),
+	show_in_getting_started: z.boolean().nullable().optional(),
+	archived: z.boolean().nullable().optional(),
+	position: z.number().int().positive().nullable().optional(),
+	width: DashboardWidth.optional(),
+	enable_embedding: z.boolean().nullable().optional(),
+	embedding_type: z.string().nullable().optional(),
+	embedding_params: EmbeddingParams.nullable().optional(),
+	parameters: z.array(Parameter).nullable().optional(),
+	cache_ttl: z.number().int().positive().nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	dashcards: z.array(DashcardWrite).nullable().optional(),
+	tabs: z.array(DashboardTabWrite).nullable().optional()
+}).loose();
+const DashcardPatchInput = z.object({
+	row: z.number().int().nonnegative().optional(),
+	col: z.number().int().nonnegative().optional(),
+	size_x: z.number().int().positive().optional(),
+	size_y: z.number().int().positive().optional(),
+	dashboard_tab_id: z.number().int().nullable().optional(),
+	parameter_mappings: z.array(ParameterMapping).nullable().optional(),
+	inline_parameters: z.array(z.string().min(1)).nullable().optional(),
+	visualization_settings: z.unknown().optional(),
+	series: z.array(z.record(z.string(), z.unknown())).nullable().optional()
+}).strict().refine((value) => Object.keys(value).length > 0, { message: "patch must contain at least one field" });
+const DashboardCopyInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	description: z.string().nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	is_deep_copy: z.boolean().nullable().optional()
+}).strict();
+const DashboardUncopiedCard = z.object({ id: z.number().int() }).loose();
+const DashboardCopy = Dashboard.extend({ uncopied: z.array(DashboardUncopiedCard).optional() });
+const DashboardCopyCompact = DashboardCompact.extend({ uncopied: z.array(DashboardUncopiedCard.pick({ id: true }).strip()).optional() });
+const ParameterConstraintValue = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]);
+/**
+* Values of other parameters on a dashboard, by parameter id, that narrow the values a linked
+* parameter offers. An array sets several values for one parameter.
+*/
+const DashboardParameterConstraints = z.record(z.string().min(1), z.union([ParameterConstraintValue, z.array(ParameterConstraintValue)]));
+//#endregion
+export { Dashboard, DashboardCompact, DashboardCopy, DashboardCopyCompact, DashboardCopyInput, DashboardCreateInput, DashboardDetail, DashboardListFilter, DashboardParameterConstraints, DashboardTab, DashboardTabCompact, DashboardUncopiedCard, DashboardUpdateInput, Dashcard, DashcardCompact, DashcardDetail, DashcardPatchInput, DashcardVirtualCard, DashcardVisualizationSettings, UnreadableCard };

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

@@ -0,0 +1,2 @@
+import { a as DataActionExecuteResult, c as dataActionSchema, i as DataActionExecuteInput, n as DataActionCompact, o as DataActionParameter, r as DataActionCreateInput, s as DataActionUpdateInput, t as DataAction } from "../data-action-rS27f2Ji.js";
+export { DataAction, DataActionCompact, DataActionCreateInput, DataActionExecuteInput, DataActionExecuteResult, DataActionParameter, DataActionUpdateInput, dataActionSchema };

package/dist/domain/data-action.js

@@ -0,0 +1,85 @@
+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 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: z.number().int().positive().nullable().optional(),
+	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 { DataAction, DataActionCompact, DataActionCreateInput, DataActionExecuteInput, DataActionExecuteResult, DataActionParameter, DataActionUpdateInput, dataActionSchema };

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-BLUMlywE.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-C6lX1-cr.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-D8Qs5Xdx.js";
+export { BreakingSource, BreakingSourceCompact, DependencyEdge, DependencyEntity, DependencyEntityCompact, DependencyEntityData, DependencyErrorSourceType, DependencyFindingError, DependencyFindingErrorType, DependencyGraph, DependencyGraphCompact, DependencyItemsSortColumn, DependencyNode, DependencyNodeCompact, DependencyType, DependencyUsageType, DependentsSortColumn };