@metabase/client 0.0.0-stage → 0.1.1

package/dist/document-tLd6pYWe.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+//#region src/domain/document.d.ts
+declare const TipTapNode: z.ZodObject<{
+  type: z.ZodString;
+  text: z.ZodOptional<z.ZodString>;
+  attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  marks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  content: z.ZodOptional<z.ZodArray<z.ZodObject< /*elided*/ any, z.core.$loose>>>;
+}, z.core.$loose>;
+type TipTapNode = z.infer<typeof TipTapNode>;
+declare const TipTapNodeInput: z.ZodObject<{
+  type: z.ZodString;
+  text: z.ZodOptional<z.ZodString>;
+  attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  marks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  content: z.ZodOptional<z.ZodArray<z.ZodObject< /*elided*/ any, z.core.$loose>>>;
+}, z.core.$loose>;
+type TipTapNodeInput = z.infer<typeof TipTapNodeInput>;
+declare const Document: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  document: z.ZodNullable<z.ZodObject<{
+    type: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    marks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    content: z.ZodOptional<z.ZodArray<z.ZodObject< /*elided*/ any, z.core.$loose>>>;
+  }, z.core.$loose>>;
+  entity_id: z.ZodNullable<z.ZodString>;
+  collection_id: z.ZodNullable<z.ZodNumber>;
+  collection_position: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  creator_id: z.ZodNumber;
+  creator: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    email: z.ZodString;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+  }, z.core.$loose>>>;
+  archived: z.ZodBoolean;
+  can_write: z.ZodOptional<z.ZodBoolean>;
+  can_delete: z.ZodOptional<z.ZodBoolean>;
+  can_restore: z.ZodOptional<z.ZodBoolean>;
+  is_remote_synced: z.ZodOptional<z.ZodBoolean>;
+  created_at: z.ZodString;
+  updated_at: z.ZodString;
+}, z.core.$loose>;
+type Document = z.infer<typeof Document>;
+declare const DocumentCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  archived: z.ZodBoolean;
+  creator_id: z.ZodNumber;
+  collection_id: z.ZodNullable<z.ZodNumber>;
+  can_write: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type DocumentCompact = z.infer<typeof DocumentCompact>;
+declare const DocumentCreateInput: z.ZodObject<{
+  name: z.ZodString;
+  document: z.ZodObject<{
+    type: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    marks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    content: z.ZodOptional<z.ZodArray<z.ZodObject< /*elided*/ any, z.core.$loose>>>;
+  }, z.core.$loose>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  collection_position: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  cards: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    dataset_query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    display: z.ZodString;
+    visualization_settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    entity_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parameters: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    parameter_mappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result_metadata: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    cache_ttl: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$loose>>>>;
+}, z.core.$loose>;
+type DocumentCreateInput = z.infer<typeof DocumentCreateInput>;
+declare const DocumentUpdateInput: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  document: z.ZodOptional<z.ZodObject<{
+    type: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    marks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    content: z.ZodOptional<z.ZodArray<z.ZodObject< /*elided*/ any, z.core.$loose>>>;
+  }, z.core.$loose>>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  collection_position: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  archived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  cards: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    dataset_query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    display: z.ZodString;
+    visualization_settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    entity_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parameters: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    parameter_mappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result_metadata: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+    cache_ttl: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$loose>>>>;
+}, z.core.$loose>;
+type DocumentUpdateInput = z.infer<typeof DocumentUpdateInput>;
+declare const DocumentCopyInput: z.ZodObject<{
+  name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  collection_position: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+type DocumentCopyInput = z.infer<typeof DocumentCopyInput>;
+//#endregion
+export { DocumentUpdateInput as a, DocumentCreateInput as i, DocumentCompact as n, TipTapNode as o, DocumentCopyInput as r, TipTapNodeInput as s, Document as t };

package/dist/domain/api-key.d.ts

@@ -0,0 +1,2 @@
+import { a as CreatedApiKeyCompact, i as CreatedApiKey, n as ApiKeyCompact, r as ApiKeyCreateInput, t as ApiKey } from "../api-key-DJeN1-7G.js";
+export { ApiKey, ApiKeyCompact, ApiKeyCreateInput, CreatedApiKey, CreatedApiKeyCompact };

package/dist/domain/api-key.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+//#region src/domain/api-key.ts
+const ApiKeyGroup = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const ApiKey = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	masked_key: z.string(),
+	group: ApiKeyGroup,
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const ApiKeyCompact = ApiKey.pick({
+	id: true,
+	name: true,
+	masked_key: true
+}).strip();
+const CreatedApiKey = ApiKey.extend({ unmasked_key: z.string() });
+const CreatedApiKeyCompact = CreatedApiKey.pick({
+	id: true,
+	name: true,
+	unmasked_key: true
+}).strip();
+const ApiKeyCreateInput = z.object({
+	name: z.string().min(1),
+	group_id: z.number().int().positive()
+}).strict();
+//#endregion
+export { ApiKey, ApiKeyCompact, ApiKeyCreateInput, CreatedApiKey, CreatedApiKeyCompact };

package/dist/domain/card.d.ts

@@ -0,0 +1,2 @@
+import { a as CardListFilter, c as CardType, i as CardDetail, l as CardUpdateInput, n as CardCompact, o as CardQueryResult, r as CardCreateInput, s as CardQueryResultCompact, t as Card, u as ResultColumn } from "../card-BxBzr5Uj.js";
+export { Card, CardCompact, CardCreateInput, CardDetail, CardListFilter, CardQueryResult, CardQueryResultCompact, CardType, CardUpdateInput, ResultColumn };

package/dist/domain/card.js

@@ -0,0 +1,140 @@
+import { EmbeddingParams } from "./embedding.js";
+import { FieldBaseType, FieldSemanticType } from "./field.js";
+import { ModerationReview } from "./moderation-review.js";
+import { Parameter, ParameterMapping } from "./parameter.js";
+import { DatasetQuery } from "./query.js";
+import { z } from "zod";
+//#region src/domain/card.ts
+const CardType = z.enum([
+	"question",
+	"model",
+	"metric"
+]);
+const CardQueryType = z.enum(["native", "query"]);
+const CardListFilter = z.enum([
+	"all",
+	"mine",
+	"bookmarked",
+	"database",
+	"table",
+	"archived",
+	"using_model",
+	"using_segment"
+]);
+const ResultColumn = z.object({
+	name: z.string(),
+	display_name: z.string().nullable().optional(),
+	base_type: FieldBaseType.optional(),
+	effective_type: FieldBaseType.nullable().optional(),
+	semantic_type: FieldSemanticType.nullable().optional(),
+	database_type: z.string().nullable().optional(),
+	id: z.number().int().nullable().optional()
+}).loose();
+const Card = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	type: CardType,
+	display: z.string(),
+	description: z.string().nullable(),
+	archived: z.boolean(),
+	query_type: CardQueryType.nullable(),
+	database_id: z.number().int().nullable(),
+	table_id: z.number().int().nullable(),
+	collection_id: z.number().int().nullable(),
+	dashboard_id: z.number().int().nullable().optional(),
+	entity_id: z.string().nullable(),
+	creator_id: z.number().int(),
+	dataset_query: z.unknown(),
+	visualization_settings: z.unknown(),
+	collection_position: z.number().int().nullable(),
+	moderation_reviews: z.array(ModerationReview).optional()
+}).loose();
+const CardDetail = Card.extend({
+	parameters: z.array(Parameter).nullable(),
+	result_metadata: z.array(ResultColumn).nullable()
+});
+const CardCompact = Card.pick({
+	id: true,
+	name: true,
+	type: true,
+	display: true,
+	archived: true,
+	database_id: true,
+	collection_id: true,
+	dashboard_id: true,
+	description: true
+}).strip();
+const CollectionIdOrEntityId = z.union([z.number().int().positive(), z.string().length(21).describe("collection entity_id (21-char NanoID)")]);
+const CardCreateInput = z.object({
+	name: z.string().min(1),
+	type: CardType.nullable().optional(),
+	dataset_query: DatasetQuery,
+	display: z.string().min(1),
+	visualization_settings: z.record(z.string(), z.unknown()),
+	description: z.string().min(1).nullable().optional(),
+	entity_id: z.string().min(1).nullable().optional(),
+	collection_id: CollectionIdOrEntityId.nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	cache_ttl: z.number().int().positive().nullable().optional(),
+	dashboard_id: z.number().int().positive().nullable().optional(),
+	dashboard_tab_id: z.number().int().positive().nullable().optional(),
+	parameters: z.array(Parameter).nullable().optional(),
+	parameter_mappings: z.array(ParameterMapping).nullable().optional(),
+	result_metadata: z.array(z.unknown()).nullable().optional()
+}).loose();
+const CardUpdateInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	type: CardType.nullable().optional(),
+	dataset_query: DatasetQuery.optional(),
+	display: z.string().min(1).nullable().optional(),
+	visualization_settings: z.record(z.string(), z.unknown()).nullable().optional(),
+	description: z.string().nullable().optional(),
+	archived: z.boolean().nullable().optional(),
+	enable_embedding: z.boolean().nullable().optional(),
+	embedding_type: z.string().nullable().optional(),
+	embedding_params: EmbeddingParams.nullable().optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	collection_position: z.number().int().positive().nullable().optional(),
+	collection_preview: z.boolean().nullable().optional(),
+	cache_ttl: z.number().int().positive().nullable().optional(),
+	dashboard_id: z.number().int().positive().nullable().optional(),
+	dashboard_tab_id: z.number().int().positive().nullable().optional(),
+	parameters: z.array(Parameter).nullable().optional(),
+	parameter_mappings: z.array(ParameterMapping).nullable().optional(),
+	result_metadata: z.array(z.unknown()).nullable().optional()
+}).loose();
+const CardQueryData = z.object({
+	rows: z.array(z.array(z.unknown())),
+	cols: z.array(ResultColumn),
+	rows_truncated: z.number().int().optional(),
+	pivot_rows_truncated: z.number().int().optional()
+}).loose();
+const CardQueryResult = z.object({
+	status: z.string(),
+	row_count: z.number().int().nonnegative().optional(),
+	data: CardQueryData.optional(),
+	cached: z.string().nullable().optional(),
+	error: z.string().nullable().optional(),
+	error_type: z.string().nullable().optional()
+}).loose();
+const ResultColumnCompact = ResultColumn.pick({
+	name: true,
+	display_name: true,
+	base_type: true,
+	semantic_type: true
+}).strip();
+const CardQueryDataCompact = z.object({
+	rows: z.array(z.array(z.unknown())),
+	cols: z.array(ResultColumnCompact),
+	rows_truncated: CardQueryData.shape.rows_truncated,
+	pivot_rows_truncated: CardQueryData.shape.pivot_rows_truncated
+}).strip();
+const CardQueryResultCompact = CardQueryResult.pick({
+	status: true,
+	row_count: true,
+	cached: true,
+	error: true,
+	error_type: true
+}).strip().extend({ data: CardQueryDataCompact.optional() });
+//#endregion
+export { Card, CardCompact, CardCreateInput, CardDetail, CardListFilter, CardQueryResult, CardQueryResultCompact, CardType, CardUpdateInput, ResultColumn };

package/dist/domain/collection.d.ts

@@ -0,0 +1,2 @@
+import { _ as CollectionType, a as CollectionAuthorityLevel, c as CollectionId, d as CollectionItemFilterModel, f as CollectionItemModel, g as CollectionTreeNode, h as CollectionPinnedState, i as Collection, l as CollectionItem, m as CollectionNamespace, n as COLLECTION_ITEM_MODELS, o as CollectionCompact, p as CollectionListFilter, r as COLLECTION_PINNED_STATES, s as CollectionCreateInput, t as COLLECTION_ITEM_FILTER_MODELS, u as CollectionItemCompact, v as CollectionUpdateInput } from "../collection-DGnTvD6R.js";
+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/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 { S as dashboardDetailSchema, _ as DashcardDetail, a as DashboardCopyInput, b as DashcardVisualizationSettings, c as DashboardLayoutInput, d as DashboardTab, f as DashboardTabCompact, g as DashcardCompact, h as Dashcard, i as DashboardCopyCompact, l as DashboardListFilter, m as DashboardUpdateInput, n as DashboardCompact, o as DashboardCreateInput, p as DashboardUncopiedCard, r as DashboardCopy, s as DashboardDetail, t as Dashboard, u as DashboardParameterConstraints, v as DashcardPatchInput, x as UnreadableCard, y as DashcardVirtualCard } from "../dashboard-DtLXVgtf.js";
+export { Dashboard, DashboardCompact, DashboardCopy, DashboardCopyCompact, DashboardCopyInput, DashboardCreateInput, DashboardDetail, DashboardLayoutInput, DashboardListFilter, DashboardParameterConstraints, DashboardTab, DashboardTabCompact, DashboardUncopiedCard, DashboardUpdateInput, Dashcard, DashcardCompact, DashcardDetail, DashcardPatchInput, DashcardVirtualCard, DashcardVisualizationSettings, UnreadableCard, dashboardDetailSchema };

package/dist/domain/dashboard.js

@@ -0,0 +1,211 @@
+import { EmbeddingParams } from "./embedding.js";
+import { Parameter, ParameterMapping } from "./parameter.js";
+import { Card } from "./card.js";
+import { NonBlankText } from "./text.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` `null`, and its `card` reads as `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 NoCardStub = z.object({
+	id: z.never().optional(),
+	name: z.never().optional()
+}).loose().transform(() => null);
+const DashcardDetailWire = DashcardDetail.extend({ card: z.union([
+	Card,
+	UnreadableCard,
+	NoCardStub
+]).nullable() });
+/**
+* The dashboard `GET` and `PUT /api/dashboard/{id}` answer, read as `DashboardDetail`: the stub card
+* of a dashcard bound to no card reads as `null`.
+*/
+const dashboardDetailSchema = DashboardDetail.extend({ dashcards: z.array(DashcardDetailWire) });
+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: NonBlankText,
+	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()
+}).strip();
+const DashboardLayoutInput = z.object({
+	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, DashboardLayoutInput, DashboardListFilter, DashboardParameterConstraints, DashboardTab, DashboardTabCompact, DashboardUncopiedCard, DashboardUpdateInput, Dashcard, DashcardCompact, DashcardDetail, DashcardPatchInput, DashcardVirtualCard, DashcardVisualizationSettings, UnreadableCard, dashboardDetailSchema };

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

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