@metabase/client 0.0.0-stage → 0.1.1

package/dist/domain/replacement.js

@@ -0,0 +1,93 @@
+import { FieldBaseType, FieldSemanticType } from "./field.js";
+import { TransformTarget } from "./transform.js";
+import { z } from "zod";
+//#region src/domain/replacement.ts
+const ReplacementSourceType = z.enum(["card", "table"]);
+const ReplacementEntityType = z.enum([...ReplacementSourceType.options, "transform"]);
+const ReplacementRunStatus = z.enum([
+	"pending",
+	"started",
+	"succeeded",
+	"failed",
+	"canceled",
+	"timeout"
+]);
+const ReplacementRun = z.object({
+	id: z.number().int(),
+	status: ReplacementRunStatus,
+	is_active: z.literal(true).nullable(),
+	source_entity_type: ReplacementEntityType,
+	source_entity_id: z.number().int(),
+	target_entity_type: ReplacementEntityType,
+	target_entity_id: z.number().int(),
+	progress: z.number().min(0).max(1).nullable(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable()
+}).loose();
+const ReplacementRunCompact = ReplacementRun.pick({
+	id: true,
+	status: true,
+	source_entity_type: true,
+	source_entity_id: true,
+	target_entity_type: true,
+	target_entity_id: true,
+	progress: true,
+	message: true,
+	start_time: true,
+	end_time: true
+}).strip();
+const ReplacementColumn = z.object({
+	id: z.number().int().nullable(),
+	name: z.string(),
+	display_name: z.string(),
+	base_type: FieldBaseType.nullable(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable()
+});
+const ReplacementColumnError = z.enum([
+	"column-type-mismatch",
+	"missing-primary-key",
+	"missing-foreign-key",
+	"foreign-key-mismatch"
+]);
+const ReplacementColumnMatched = z.object({
+	source: ReplacementColumn,
+	target: ReplacementColumn,
+	errors: z.array(ReplacementColumnError).optional()
+}).strict();
+const ReplacementColumnMissingOnTarget = z.object({ source: ReplacementColumn }).strict();
+const ReplacementColumnMissingOnSource = z.object({ target: ReplacementColumn }).strict();
+const ReplacementColumnMapping = z.union([
+	ReplacementColumnMatched,
+	ReplacementColumnMissingOnTarget,
+	ReplacementColumnMissingOnSource
+]);
+const ReplacementError = z.enum([
+	"cycle-detected",
+	"database-mismatch",
+	"incompatible-implicit-joins",
+	"affects-gtap-policies"
+]);
+const ReplacementCheck = z.object({
+	success: z.boolean(),
+	errors: z.array(ReplacementError).optional(),
+	column_mappings: z.array(ReplacementColumnMapping).optional()
+});
+const ReplacementSourceInput = z.object({
+	source_entity_id: z.number().int().positive(),
+	source_entity_type: ReplacementSourceType,
+	target_entity_id: z.number().int().positive(),
+	target_entity_type: ReplacementSourceType
+}).strict();
+const ReplacementModelWithTransformInput = z.object({
+	card_id: z.number().int().positive(),
+	transform_name: z.string(),
+	transform_target: TransformTarget,
+	target_collection_id: z.number().int().positive().nullable().optional(),
+	transform_tag_ids: z.array(z.number().int().positive()).nullable().optional()
+}).strict();
+const ReplacementRunStarted = z.object({ run_id: z.number().int().positive() });
+//#endregion
+export { ReplacementCheck, ReplacementColumn, ReplacementColumnError, ReplacementColumnMapping, ReplacementEntityType, ReplacementError, ReplacementModelWithTransformInput, ReplacementRun, ReplacementRunCompact, ReplacementRunStarted, ReplacementRunStatus, ReplacementSourceInput, ReplacementSourceType };

package/dist/domain/revision.d.ts

@@ -0,0 +1,2 @@
+import { a as RevisionRevert, i as RevisionEntity, n as Revision, o as RevisionRevertInput, r as RevisionCompact, s as RevisionRow, t as REVISION_ENTITY_GATES } from "../revision-Dyl-8p7d.js";
+export { REVISION_ENTITY_GATES, Revision, RevisionCompact, RevisionEntity, RevisionRevert, RevisionRevertInput, RevisionRow };

package/dist/domain/revision.js

@@ -0,0 +1,90 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { z } from "zod";
+//#region src/domain/revision.ts
+const RevisionEntity = z.enum([
+	"card",
+	"dashboard",
+	"document",
+	"measure",
+	"segment",
+	"transform",
+	"transform-test"
+]);
+const RevisionUser = z.object({
+	id: z.number().int(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable(),
+	common_name: z.string()
+}).loose();
+const Revision = z.object({
+	id: z.number().int(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean(),
+	diff: z.object({}).loose().nullable(),
+	description: z.string(),
+	has_multiple_changes: z.boolean(),
+	user: RevisionUser
+}).loose();
+const RevisionCompact = Revision.pick({
+	id: true,
+	timestamp: true,
+	is_creation: true,
+	is_reversion: true,
+	description: true,
+	user: true
+}).strip();
+const RevisionRow = z.object({
+	id: z.number().int(),
+	model: z.string(),
+	model_id: z.number().int(),
+	user_id: z.number().int(),
+	object: z.object({}).loose(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean()
+}).loose();
+const REVISION_ENTITY_GATES = [
+	{
+		feature: "measures",
+		effect: "needs",
+		when: {
+			kind: "values",
+			values: ["measure"]
+		}
+	},
+	{
+		feature: "transforms",
+		effect: "needs",
+		when: {
+			kind: "values",
+			values: ["transform"]
+		}
+	},
+	{
+		feature: "transformTests",
+		effect: "needs",
+		when: {
+			kind: "values",
+			values: ["transform-test"]
+		}
+	}
+];
+const RevisionRevertInput = z.object({
+	entity: gateInput(z.enum(RevisionEntity.options), ...REVISION_ENTITY_GATES),
+	id: z.number().int().positive(),
+	revision_id: z.number().int().positive()
+}).strict();
+const RevisionReverted = z.object({
+	outcome: z.literal("reverted"),
+	revision: Revision
+});
+const RevisionUnchanged = z.object({
+	outcome: z.literal("unchanged"),
+	revision: RevisionRow
+});
+const RevisionRevert = z.discriminatedUnion("outcome", [RevisionReverted, RevisionUnchanged]);
+//#endregion
+export { REVISION_ENTITY_GATES, Revision, RevisionCompact, RevisionEntity, RevisionRevert, RevisionRevertInput, RevisionRow };

package/dist/domain/search.d.ts

@@ -0,0 +1,2 @@
+import { i as SearchResultCompact, n as SearchModel, r as SearchResult, t as SEARCH_MODELS } from "../search-Cm5IxKss.js";
+export { SEARCH_MODELS, SearchModel, SearchResult, SearchResultCompact };

package/dist/domain/search.js

@@ -0,0 +1,63 @@
+import { ModerationStatus } from "./moderation-review.js";
+import { z } from "zod";
+//#region src/domain/search.ts
+const SEARCH_MODELS = [
+	"card",
+	"dataset",
+	"metric",
+	"dashboard",
+	"collection",
+	"database",
+	"table",
+	"segment",
+	"measure",
+	"document",
+	"exploration",
+	"action",
+	"transform",
+	"indexed-entity"
+];
+const SearchModel = z.enum(SEARCH_MODELS);
+const SearchResultCollection = z.object({
+	id: z.union([
+		z.number().int(),
+		z.string(),
+		z.null()
+	]),
+	name: z.string().nullable(),
+	authority_level: z.string().nullable(),
+	type: z.string().nullable()
+}).loose();
+const SearchResultDashboard = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const SearchResult = z.object({
+	id: z.union([z.number().int(), z.string()]),
+	name: z.string(),
+	model: SearchModel,
+	description: z.string().nullable().optional(),
+	archived: z.boolean().nullable(),
+	collection: SearchResultCollection.nullable(),
+	result_metadata: z.array(z.unknown()).nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	database_name: z.string().nullable().optional(),
+	table_schema: z.string().nullable().optional(),
+	table_name: z.string().nullable().optional(),
+	moderated_status: ModerationStatus.nullable().optional(),
+	dashboard: SearchResultDashboard.nullable().optional()
+}).loose();
+const SearchResultCompact = SearchResult.pick({
+	id: true,
+	name: true,
+	model: true,
+	description: true,
+	database_name: true,
+	table_schema: true,
+	table_name: true
+}).strip().extend({ dashboard: SearchResultDashboard.pick({
+	id: true,
+	name: true
+}).strip().nullable().optional() });
+//#endregion
+export { SEARCH_MODELS, SearchModel, SearchResult, SearchResultCompact };

package/dist/domain/segment.d.ts

@@ -0,0 +1,2 @@
+import { i as SegmentUpdateInput, n as SegmentCompact, r as SegmentCreateInput, t as Segment } from "../segment-CbAgVO-5.js";
+export { Segment, SegmentCompact, SegmentCreateInput, SegmentUpdateInput };

package/dist/domain/segment.js

@@ -0,0 +1,46 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { TABLE_FROM_DEFINITION_GATE } from "./table.js";
+import { z } from "zod";
+//#region src/domain/segment.ts
+const Segment = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	archived: z.boolean(),
+	table_id: z.number().int(),
+	definition: z.unknown(),
+	creator_id: z.number().int(),
+	entity_id: z.string().nullable(),
+	show_in_getting_started: z.boolean().nullable(),
+	caveats: z.string().nullable(),
+	points_of_interest: z.string().nullable(),
+	definition_description: z.string().nullable().optional(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const SegmentCompact = Segment.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	table_id: true
+}).strip();
+const SegmentDefinition = z.record(z.string(), z.unknown()).describe("MBQL query holding the filter");
+const SegmentCreateInput = z.object({
+	name: z.string().min(1),
+	table_id: gateInput(z.number().int().positive(), TABLE_FROM_DEFINITION_GATE),
+	definition: SegmentDefinition,
+	description: z.string().nullable().optional()
+}).loose();
+const SegmentUpdateInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	definition: SegmentDefinition.nullable().optional(),
+	revision_message: z.string().min(1),
+	archived: z.boolean().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()
+}).loose();
+//#endregion
+export { Segment, SegmentCompact, SegmentCreateInput, SegmentUpdateInput };

package/dist/domain/session-properties.d.ts

@@ -0,0 +1,2 @@
+import { n as TokenFeatures, t as SessionProperties } from "../session-properties-COtlxAcK.js";
+export { SessionProperties, TokenFeatures };

package/dist/domain/session-properties.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+//#region src/domain/session-properties.ts
+const ServerVersion = z.object({
+	tag: z.string(),
+	date: z.string().optional(),
+	hash: z.string().optional()
+}).loose();
+const TokenFeatures = z.record(z.string(), z.boolean());
+const SessionProperties = z.object({
+	version: ServerVersion,
+	"token-features": TokenFeatures.optional()
+}).loose();
+//#endregion
+export { SessionProperties, TokenFeatures };

package/dist/domain/setting.d.ts

@@ -0,0 +1,2 @@
+import { n as SettingCompact, r as SettingValue, t as Setting } from "../setting-DXuQGXGF.js";
+export { Setting, SettingCompact, SettingValue };

package/dist/domain/setting.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/domain/setting.ts
+const Setting = z.object({
+	key: z.string(),
+	value: z.unknown(),
+	is_env_setting: z.boolean(),
+	env_name: z.string(),
+	description: z.string(),
+	default: z.unknown()
+}).loose();
+const SettingCompact = Setting.pick({
+	key: true,
+	value: true,
+	is_env_setting: true,
+	env_name: true
+}).strip();
+const SettingValue = z.object({
+	key: z.string(),
+	value: z.unknown()
+});
+//#endregion
+export { Setting, SettingCompact, SettingValue };

package/dist/domain/setup.d.ts

@@ -0,0 +1,2 @@
+import { n as SetupResult, r as SetupResultCompact, t as SetupInput } from "../setup-JqcJ2unJ.js";
+export { SetupInput, SetupResult, SetupResultCompact };

package/dist/domain/setup.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+//#region src/domain/setup.ts
+const SetupUserInput = z.object({
+	first_name: z.string().min(1).nullable().optional(),
+	last_name: z.string().min(1).nullable().optional(),
+	email: z.string(),
+	password: z.string().min(1).describe("must satisfy the server's password complexity requirements")
+}).loose();
+const SetupPrefsInput = z.object({
+	site_name: z.string().min(1),
+	site_locale: z.string().min(1).nullable().optional()
+}).loose();
+const SetupInput = z.object({
+	token: z.string().min(1),
+	user: SetupUserInput,
+	prefs: SetupPrefsInput
+}).loose();
+const SetupResult = z.object({ id: z.string() }).loose();
+const SetupResultCompact = SetupResult.pick({ id: true }).strip();
+//#endregion
+export { SetupInput, SetupResult, SetupResultCompact };

package/dist/domain/snippet.d.ts

@@ -0,0 +1,2 @@
+import { i as SnippetUpdateInput, n as SnippetCompact, r as SnippetCreateInput, t as Snippet } from "../snippet-C_Ilx7tR.js";
+export { Snippet, SnippetCompact, SnippetCreateInput, SnippetUpdateInput };

package/dist/domain/snippet.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+//#region src/domain/snippet.ts
+const Snippet = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	content: z.string(),
+	archived: z.boolean(),
+	collection_id: z.number().int().nullable(),
+	creator_id: z.number().int(),
+	entity_id: z.string().nullable(),
+	template_tags: z.record(z.string(), z.unknown()).nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const SnippetCompact = Snippet.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	collection_id: true
+}).strip();
+const snippetName = z.string().regex(/^(?!\s)[^}]*$/, "snippet names cannot include '}' or start with spaces");
+const SnippetCreateInput = z.object({
+	name: snippetName,
+	content: z.string(),
+	description: z.string().nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional()
+}).loose();
+const SnippetUpdateInput = z.object({
+	name: snippetName.nullable().optional(),
+	content: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	archived: z.boolean().nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional()
+}).loose();
+//#endregion
+export { Snippet, SnippetCompact, SnippetCreateInput, SnippetUpdateInput };

package/dist/domain/table.d.ts

@@ -0,0 +1,2 @@
+import { C as TableSelectionResult, E as TableVisibilityType, S as TableSchemaSyncResult, T as TableUpdateInput, _ as TableForeignKeyCompact, a as Table, b as TableQueryMetadataCompact, c as TableBulkEditResult, d as TableDataLayerMedallion, f as TableDataLayerTier, g as TableForeignKey, h as TableFieldValuesResult, i as TABLE_FROM_DEFINITION_GATE, l as TableCompact, m as TableDatabase, n as DATA_LAYER_MEDALLION_GATE, o as TableBulkEditFields, p as TableDataSource, r as DATA_LAYER_TIER_GATE, s as TableBulkEditInput, t as DATA_AUTHORITY_WITHDRAWAL_GATE, u as TableDataLayer, v as TableGetInclude, w as TableSelectors, x as TableSchemaId, y as TableQueryMetadata } from "../table-Od6uvDVW.js";
+export { DATA_AUTHORITY_WITHDRAWAL_GATE, DATA_LAYER_MEDALLION_GATE, DATA_LAYER_TIER_GATE, TABLE_FROM_DEFINITION_GATE, Table, TableBulkEditFields, TableBulkEditInput, TableBulkEditResult, TableCompact, TableDataLayer, TableDataLayerMedallion, TableDataLayerTier, TableDataSource, TableDatabase, TableFieldValuesResult, TableForeignKey, TableForeignKeyCompact, TableGetInclude, TableQueryMetadata, TableQueryMetadataCompact, TableSchemaId, TableSchemaSyncResult, TableSelectionResult, TableSelectors, TableUpdateInput, TableVisibilityType };

package/dist/domain/table.js

@@ -0,0 +1,187 @@
+import { t as gateInput } from "../input-gate-registry-Dai7SfXb.js";
+import { Field, FieldCompact, FieldWithTarget } from "./field.js";
+import { z } from "zod";
+//#region src/domain/table.ts
+const TableEntityType = z.enum([
+	"entity/GenericTable",
+	"entity/UserTable",
+	"entity/CompanyTable",
+	"entity/TransactionTable",
+	"entity/ProductTable",
+	"entity/SubscriptionTable",
+	"entity/EventTable"
+]);
+const TableVisibilityType = z.enum([
+	"hidden",
+	"technical",
+	"cruft"
+]);
+const TableFieldOrder = z.enum([
+	"alphabetical",
+	"custom",
+	"database",
+	"smart"
+]);
+const TableDataAuthority = z.enum([
+	"unconfigured",
+	"authoritative",
+	"computed",
+	"ingested"
+]);
+const TableDataLayerTier = z.enum([
+	"final",
+	"internal",
+	"hidden"
+]);
+const TableDataLayerMedallion = z.enum([
+	"gold",
+	"silver",
+	"bronze",
+	"copper"
+]);
+const TableDataLayer = z.enum([...TableDataLayerTier.options, ...TableDataLayerMedallion.options]);
+const Table = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	display_name: z.string(),
+	description: z.string().nullable(),
+	caveats: z.string().nullable(),
+	db_id: z.number().int(),
+	schema: z.string().nullable(),
+	entity_type: TableEntityType.nullable(),
+	visibility_type: TableVisibilityType.nullable().optional(),
+	data_layer: TableDataLayer.nullable(),
+	estimated_row_count: z.number().int().nullable(),
+	active: z.boolean(),
+	is_published: z.boolean().optional(),
+	collection_id: z.number().int().nullable().optional(),
+	fields: z.array(Field).optional()
+}).loose();
+const TableDatabase = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	engine: z.string(),
+	features: z.array(z.string()).optional()
+}).loose();
+const TableQueryMetadata = Table.extend({
+	fields: z.array(FieldWithTarget),
+	db: TableDatabase
+});
+const TableGetInclude = z.enum(["fields"]);
+const TableCompact = Table.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	description: true,
+	db_id: true,
+	schema: true,
+	entity_type: true,
+	visibility_type: true,
+	active: true,
+	is_published: true
+}).strip().extend({ fields: z.array(FieldCompact).optional() });
+const TableQueryMetadataCompact = TableCompact.extend({ fields: z.array(FieldCompact) });
+const DATA_LAYER_TIER_GATE = {
+	feature: "tableDataLayerTiers",
+	effect: "needs",
+	when: {
+		kind: "values",
+		values: TableDataLayerTier.options
+	}
+};
+const DATA_LAYER_MEDALLION_GATE = {
+	feature: "tableDataLayerTiers",
+	effect: "supersededBy",
+	when: {
+		kind: "values",
+		values: TableDataLayerMedallion.options
+	}
+};
+const TABLE_FROM_DEFINITION_GATE = {
+	feature: "tableFromDefinition",
+	effect: "droppedBy",
+	when: { kind: "present" }
+};
+const DATA_AUTHORITY_WITHDRAWAL_GATE = {
+	feature: "tableUserValueWithdrawal",
+	effect: "needs",
+	when: {
+		kind: "values",
+		values: [null]
+	}
+};
+const TableDataAuthorityInput = gateInput(TableDataAuthority.nullable().optional(), DATA_AUTHORITY_WITHDRAWAL_GATE);
+const TableDataSource = z.enum([
+	"unknown",
+	"ingested",
+	"metabase-transform",
+	"transform",
+	"source-data",
+	"upload"
+]);
+const TableUpdateInput = z.object({
+	display_name: z.string().min(1).optional(),
+	entity_type: TableEntityType.optional(),
+	visibility_type: TableVisibilityType.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().optional(),
+	field_order: TableFieldOrder.optional(),
+	data_authority: TableDataAuthorityInput,
+	data_source: TableDataSource.nullable().optional(),
+	data_layer: gateInput(TableDataLayer.nullable().optional(), DATA_LAYER_TIER_GATE, DATA_LAYER_MEDALLION_GATE),
+	owner_email: z.string().nullable().optional(),
+	owner_user_id: z.number().int().nullable().optional(),
+	collection_id: z.number().int().positive().optional()
+}).loose();
+const TableSchemaId = z.string().regex(/^[1-9]\d{0,17}:[^:]*$/, { error: "expected a schema id \"<db-id>:<schema>\" with a positive database id" });
+const TableSelectors = z.object({
+	database_ids: z.array(z.number().int().positive()).optional(),
+	schema_ids: z.array(TableSchemaId).optional(),
+	table_ids: z.array(z.number().int().positive()).optional()
+}).strict();
+const TableBulkEditFields = z.object({
+	data_authority: TableDataAuthorityInput,
+	data_source: TableDataSource.nullable().optional(),
+	data_layer: TableDataLayerTier.nullable().optional(),
+	entity_type: TableEntityType.nullable().optional(),
+	owner_email: z.string().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional()
+});
+const TableBulkEditInput = TableSelectors.extend(TableBulkEditFields.shape).strict();
+const TableSchemaSyncResult = z.object({
+	id: z.number().int(),
+	status: z.literal("ok")
+});
+const TableFieldValuesResult = z.object({
+	id: z.number().int(),
+	status: z.literal("success")
+});
+const TableSelectionResult = TableSelectors.extend({ accepted: z.literal(true) }).strict();
+const TableBulkEditResult = TableBulkEditInput.extend({ accepted: z.literal(true) }).strict();
+const TableForeignKeyEnd = Field.extend({ table: Table });
+const TableForeignKey = z.object({
+	relationship: z.literal("Mt1"),
+	origin_id: z.number().int(),
+	origin: TableForeignKeyEnd,
+	destination_id: z.number().int(),
+	destination: TableForeignKeyEnd
+}).loose();
+const TableForeignKeyOriginCompact = FieldCompact.extend({ table: Table.pick({
+	id: true,
+	name: true,
+	display_name: true,
+	schema: true,
+	db_id: true
+}).strip() });
+const TableForeignKeyCompact = TableForeignKey.pick({
+	relationship: true,
+	origin_id: true,
+	destination_id: true
+}).strip().extend({
+	origin: TableForeignKeyOriginCompact,
+	destination: FieldCompact
+});
+//#endregion
+export { DATA_AUTHORITY_WITHDRAWAL_GATE, DATA_LAYER_MEDALLION_GATE, DATA_LAYER_TIER_GATE, TABLE_FROM_DEFINITION_GATE, Table, TableBulkEditFields, TableBulkEditInput, TableBulkEditResult, TableCompact, TableDataLayer, TableDataLayerMedallion, TableDataLayerTier, TableDataSource, TableDatabase, TableFieldValuesResult, TableForeignKey, TableForeignKeyCompact, TableGetInclude, TableQueryMetadata, TableQueryMetadataCompact, TableSchemaId, TableSchemaSyncResult, TableSelectionResult, TableSelectors, TableUpdateInput, TableVisibilityType };

package/dist/domain/text.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/domain/text.d.ts
+declare const NonBlankText: z.ZodString;
+//#endregion
+export { NonBlankText };

package/dist/domain/text.js

@@ -0,0 +1,6 @@
+import { NOT_BLANK } from "../predicates.js";
+import { z } from "zod";
+//#region src/domain/text.ts
+const NonBlankText = z.string().regex(NOT_BLANK, "must not be blank");
+//#endregion
+export { NonBlankText };

package/dist/domain/timeline.d.ts

@@ -0,0 +1,2 @@
+import { a as TimelineEventCompact, c as TimelineIcon, i as TimelineEvent, l as TimelineUpdateInput, n as TimelineCompact, o as TimelineEventCreateInput, r as TimelineCreateInput, s as TimelineEventUpdateInput, t as Timeline } from "../timeline-BK45hy-h.js";
+export { Timeline, TimelineCompact, TimelineCreateInput, TimelineEvent, TimelineEventCompact, TimelineEventCreateInput, TimelineEventUpdateInput, TimelineIcon, TimelineUpdateInput };