@metabase/client 0.0.0-stage → 0.1.0

package/dist/resources/transform.js

@@ -0,0 +1,217 @@
+import { TimeoutError } from "../errors.js";
+import { paginatePages } from "../paginate.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { pollUntil } from "../poll.js";
+import { TransformDagRunResult, TransformDagTransform, TransformRun, TransformRunSummary, isTransformRunFailed, isTransformRunTerminal, transformDetailSchema, transformRowSchema } from "../domain/transform.js";
+import { z } from "zod";
+//#region src/resources/transform.ts
+function transformListSchema(features) {
+	return z.array(transformRowSchema(features));
+}
+const TransformRunKickoff = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable()
+});
+const TransformDagTransformList = z.array(TransformDagTransform);
+function transformResource(transport) {
+	const { explain, explainWalk } = explainer(transport, "transform");
+	async function requestTransformList(path, opts) {
+		const { features } = await transport.server(opts);
+		return {
+			data: await transport.requestParsed(transformListSchema(features), path, opts),
+			total: null
+		};
+	}
+	async function requestTransform(path, opts) {
+		const { features } = await transport.server(opts);
+		return transport.requestParsed(transformRowSchema(features), path, opts);
+	}
+	/** List every transform the caller can see. */
+	async function list(options = {}) {
+		return requestTransformList("/api/transform", { ...options });
+	}
+	/** Get one transform by id. */
+	async function get(id, options = {}) {
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformDetailSchema(features), `/api/transform/${id}`, { ...options });
+	}
+	/** Create a transform — a query plus the warehouse table it writes — from a full body. */
+	async function create(params, options = {}) {
+		return requestTransform("/api/transform", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a transform by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		return requestTransform(`/api/transform/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform by id, leaving any table it already materialized in place. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** Drop a transform's materialized output table, keeping the transform definition. */
+	async function deleteTable(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/table`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** List the upstream transforms a transform depends on. */
+	async function dependencies(id, options = {}) {
+		return requestTransformList(`/api/transform/${id}/dependencies`, { ...options });
+	}
+	/** Request cancellation of a transform's current run. */
+	async function cancel(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/cancel`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/** Get one transform run by run id — not by the id of the transform that produced it. */
+	async function getRun(runId, options = {}) {
+		return transport.requestParsed(TransformRun, `/api/transform/run/${runId}`, { ...options });
+	}
+	/** Walk the run history, newest first, optionally narrowed to a single transform. */
+	async function* runPages(params = {}, options = {}) {
+		yield* paginatePages(transport, "/api/transform/run", TransformRun, {
+			query: { "transform-ids": params["transform-ids"] },
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Walk the unified run history, newest first by default: every row is a root run — a job run, a
+	* DAG reprocess run, or a standalone transform run — and never a member run of a job or DAG.
+	*/
+	async function* runSummaryPages(params = {}, options = {}) {
+		yield* paginatePages(transport, "/api/transform/runs", TransformRunSummary, {
+			query: {
+				types: params.types,
+				statuses: params.statuses,
+				"run-methods": params["run-methods"],
+				"start-time": params["start-time"],
+				"end-time": params["end-time"],
+				"transform-ids": params["transform-ids"],
+				"sort-column": params["sort-column"],
+				"sort-direction": params["sort-direction"]
+			},
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Reset the stored checkpoint of an incremental transform, so its next run reprocesses the whole
+	* source rather than the rows past the last checkpoint.
+	*/
+	async function resetCheckpoint(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/reset-checkpoint`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Start a DAG reprocess run seeded at a transform: the transform plus, by `direction`, every
+	* transform it transitively depends on or every transform that transitively depends on it. The
+	* server answers at once with the run's id, or null when it ran nothing because a DAG run for
+	* this transform is already in progress or the closure is empty. Progress is read off
+	* `runSummaryPages` with `types: ["dag"]`, and the member runs off `transformDagRun.transformRuns`.
+	*/
+	async function runDag(id, params, options = {}) {
+		return transport.requestParsed(TransformDagRunResult, `/api/transform/${id}/run-dag`, {
+			...options,
+			method: "POST",
+			body: { direction: params.direction }
+		});
+	}
+	/** Preview the transforms a DAG reprocess seeded at a transform would run, in execution order. */
+	async function dagTransforms(id, params, options = {}) {
+		return {
+			data: await transport.requestParsed(TransformDagTransformList, `/api/transform/${id}/dag-transforms`, {
+				...options,
+				query: { direction: params.direction }
+			}),
+			total: null
+		};
+	}
+	/**
+	* Start a run of a transform by id. The server queues the run and answers at once; `wait` polls
+	* it to a terminal status, and `syncTarget` follows that with the output table's registration.
+	* A server that answers no run id started nothing, and there is then nothing to poll.
+	*/
+	async function run(id, params = {}, options = {}) {
+		const kickoff = await transport.requestParsed(TransformRunKickoff, `/api/transform/${id}/run`, {
+			...options,
+			method: "POST"
+		});
+		const schedule = params.syncTarget === true ? params.wait ?? {} : params.wait;
+		if (schedule === void 0 || kickoff.run_id === null) return {
+			message: kickoff.message,
+			run_id: kickoff.run_id,
+			final: null
+		};
+		const runId = kickoff.run_id;
+		const final = await pollUntil(async (signal) => getRun(runId, {
+			...options,
+			signal
+		}), (candidate) => isTransformRunTerminal(candidate.status), schedule);
+		if (params.syncTarget !== true) return {
+			message: kickoff.message,
+			run_id: runId,
+			final
+		};
+		const targetTableId = isTransformRunFailed(final.status) ? null : await awaitTargetTableId(id, schedule, options);
+		return {
+			message: kickoff.message,
+			run_id: runId,
+			final,
+			target_table_id: targetTableId
+		};
+	}
+	async function awaitTargetTableId(id, wait, options) {
+		try {
+			return (await pollUntil(async (signal) => get(id, {
+				...options,
+				signal
+			}), (transform) => transform.target_table_id !== null, wait)).target_table_id;
+		} catch (error) {
+			if (error instanceof TimeoutError) return null;
+			throw error;
+		}
+	}
+	return {
+		list: explain("list", list),
+		get: explain("get", get),
+		create: explain("create", create),
+		update: explain("update", update),
+		delete: explain("delete", remove),
+		deleteTable: explain("deleteTable", deleteTable),
+		dependencies: explain("dependencies", dependencies),
+		cancel: explain("cancel", cancel),
+		getRun: explain("getRun", getRun),
+		runPages: explainWalk("runPages", runPages),
+		runSummaryPages: explainWalk("runSummaryPages", runSummaryPages),
+		resetCheckpoint: explain("resetCheckpoint", resetCheckpoint),
+		runDag: explain("runDag", runDag),
+		dagTransforms: explain("dagTransforms", dagTransforms),
+		run: explain("run", run)
+	};
+}
+//#endregion
+export { transformResource };

package/dist/resources/upload.d.ts

@@ -0,0 +1,2 @@
+import { n as uploadResource, t as UploadCsvParams } from "../upload-B7PG3ePk.js";
+export { UploadCsvParams, uploadResource };

package/dist/resources/upload.js

@@ -0,0 +1,48 @@
+import { ResponseShapeError } from "../errors.js";
+import { buildCsvFormData } from "./csv-upload.js";
+import { UploadResult } from "../domain/upload.js";
+//#region src/resources/upload.ts
+const UPLOAD_TABLE_ID_HEADER = "metabase-table-id";
+function uploadResource(transport) {
+	/**
+	* Create a table and model populated with the values from the attached CSV. Returns the model ID
+	* if successful.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function createFromCsv(file, params, options = {}) {
+		const form = buildCsvFormData(file);
+		form.append("collection_id", params.collection_id);
+		const response = await transport.requestRaw("/api/upload/csv", {
+			...options,
+			method: "POST",
+			body: form,
+			expectContentType: "binary"
+		});
+		return parseCreateUploadResult(await response.text(), response.headers);
+	}
+	return { createFromCsv };
+}
+function parseCreateUploadResult(bodyText, headers) {
+	return UploadResult.parse({
+		model_id: parseResponseInteger(bodyText, "response body"),
+		table_id: parseResponseInteger(headers.get(UPLOAD_TABLE_ID_HEADER), `${UPLOAD_TABLE_ID_HEADER} header`)
+	});
+}
+function parseResponseInteger(value, source) {
+	const trimmed = value?.trim() ?? "";
+	if (trimmed === "") throw new ResponseShapeError(`upload succeeded but the ${source} was empty`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	const parsed = Number(trimmed);
+	if (!Number.isInteger(parsed)) throw new ResponseShapeError(`upload succeeded but the ${source} was not an integer: ${JSON.stringify(trimmed)}`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	return parsed;
+}
+//#endregion
+export { uploadResource };

package/dist/resources/user.d.ts

@@ -0,0 +1,8 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { t as CurrentUser } from "../user-2r0OBoO6.js";
+//#region src/resources/user.d.ts
+declare function userResource(transport: Transport): {
+  current: (options?: RequestOptions) => Promise<CurrentUser>;
+};
+//#endregion
+export { userResource };

package/dist/resources/user.js

@@ -0,0 +1,11 @@
+import { CurrentUser } from "../domain/user.js";
+//#region src/resources/user.ts
+function userResource(transport) {
+	/** Get the user the request's credentials authenticate as. */
+	async function current(options = {}) {
+		return transport.requestParsed(CurrentUser, "/api/user/current", { ...options });
+	}
+	return { current };
+}
+//#endregion
+export { userResource };

package/dist/revision-CQBPhohA.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+//#region src/domain/revision.d.ts
+declare const RevisionEntity: z.ZodEnum<{
+  card: "card";
+  dashboard: "dashboard";
+  document: "document";
+  measure: "measure";
+  segment: "segment";
+  transform: "transform";
+  "transform-test": "transform-test";
+}>;
+type RevisionEntity = z.infer<typeof RevisionEntity>;
+declare const Revision: z.ZodObject<{
+  id: z.ZodNumber;
+  timestamp: z.ZodString;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+  most_recent: z.ZodBoolean;
+  diff: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+  description: z.ZodString;
+  has_multiple_changes: z.ZodBoolean;
+  user: z.ZodObject<{
+    id: z.ZodNumber;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    common_name: z.ZodString;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type Revision = z.infer<typeof Revision>;
+declare const RevisionCompact: z.ZodObject<{
+  user: z.ZodObject<{
+    id: z.ZodNumber;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    common_name: z.ZodString;
+  }, z.core.$loose>;
+  id: z.ZodNumber;
+  description: z.ZodString;
+  timestamp: z.ZodString;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+}, z.core.$strip>;
+type RevisionCompact = z.infer<typeof RevisionCompact>;
+declare const RevisionRow: z.ZodObject<{
+  id: z.ZodNumber;
+  model: z.ZodString;
+  model_id: z.ZodNumber;
+  user_id: z.ZodNumber;
+  object: z.ZodObject<{}, z.core.$loose>;
+  timestamp: z.ZodString;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+  most_recent: z.ZodBoolean;
+}, z.core.$loose>;
+type RevisionRow = z.infer<typeof RevisionRow>;
+declare const RevisionRevertInput: z.ZodObject<{
+  entity: z.ZodEnum<{
+    card: "card";
+    dashboard: "dashboard";
+    document: "document";
+    measure: "measure";
+    segment: "segment";
+    transform: "transform";
+    "transform-test": "transform-test";
+  }>;
+  id: z.ZodNumber;
+  revision_id: z.ZodNumber;
+}, z.core.$strict>;
+type RevisionRevertInput = z.infer<typeof RevisionRevertInput>;
+declare const RevisionRevert: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"reverted">;
+  revision: z.ZodObject<{
+    id: z.ZodNumber;
+    timestamp: z.ZodString;
+    is_creation: z.ZodBoolean;
+    is_reversion: z.ZodBoolean;
+    most_recent: z.ZodBoolean;
+    diff: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+    description: z.ZodString;
+    has_multiple_changes: z.ZodBoolean;
+    user: z.ZodObject<{
+      id: z.ZodNumber;
+      first_name: z.ZodNullable<z.ZodString>;
+      last_name: z.ZodNullable<z.ZodString>;
+      common_name: z.ZodString;
+    }, z.core.$loose>;
+  }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"unchanged">;
+  revision: z.ZodObject<{
+    id: z.ZodNumber;
+    model: z.ZodString;
+    model_id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    object: z.ZodObject<{}, z.core.$loose>;
+    timestamp: z.ZodString;
+    is_creation: z.ZodBoolean;
+    is_reversion: z.ZodBoolean;
+    most_recent: z.ZodBoolean;
+  }, z.core.$loose>;
+}, z.core.$strip>], "outcome">;
+type RevisionRevert = z.infer<typeof RevisionRevert>;
+//#endregion
+export { RevisionRevertInput as a, RevisionRevert as i, RevisionCompact as n, RevisionRow as o, RevisionEntity as r, Revision as t };

package/dist/search-BxJipLN6.d.ts

@@ -0,0 +1,26 @@
+import { f as RequestOptions, h as Transport } from "./transport-E0ZaPNWJ.js";
+import { n as SearchModel, r as SearchResult } from "./search-NZR6iRBs.js";
+//#region src/resources/search.d.ts
+interface SearchPage {
+  data: SearchResult[];
+  total: number;
+}
+interface SearchParams {
+  q?: string | undefined;
+  models?: ReadonlyArray<SearchModel> | undefined;
+  archived?: boolean | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  table_db_id?: number | undefined;
+  verified?: boolean | undefined;
+  collection?: number | undefined;
+  created_by?: ReadonlyArray<number> | undefined;
+  search_native_query?: boolean | undefined;
+  include_metadata?: boolean | undefined;
+  include_dashboard_questions?: boolean | undefined;
+}
+declare function searchResource(transport: Transport): {
+  query: (params?: SearchParams | undefined, options?: RequestOptions | undefined) => Promise<SearchPage>;
+};
+//#endregion
+export { SearchParams as n, searchResource as r, SearchPage as t };

package/dist/search-NZR6iRBs.d.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+//#region src/domain/search.d.ts
+declare const SEARCH_MODELS: readonly ["card", "dataset", "metric", "dashboard", "collection", "database", "table", "segment", "measure", "document", "exploration", "action", "transform", "indexed-entity"];
+declare const SearchModel: z.ZodEnum<{
+  card: "card";
+  collection: "collection";
+  dashboard: "dashboard";
+  database: "database";
+  dataset: "dataset";
+  document: "document";
+  metric: "metric";
+  measure: "measure";
+  segment: "segment";
+  table: "table";
+  transform: "transform";
+  exploration: "exploration";
+  "indexed-entity": "indexed-entity";
+  action: "action";
+}>;
+type SearchModel = z.infer<typeof SearchModel>;
+declare const SearchResult: z.ZodObject<{
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  name: z.ZodString;
+  model: z.ZodEnum<{
+    card: "card";
+    collection: "collection";
+    dashboard: "dashboard";
+    database: "database";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    segment: "segment";
+    table: "table";
+    transform: "transform";
+    exploration: "exploration";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodNullable<z.ZodBoolean>;
+  collection: z.ZodNullable<z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>;
+    name: z.ZodNullable<z.ZodString>;
+    authority_level: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodString>;
+  }, z.core.$loose>>;
+  result_metadata: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnknown>>>;
+  database_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  database_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  table_schema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  table_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  moderated_status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    verified: "verified";
+  }>>>;
+  dashboard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+  }, z.core.$loose>>>;
+}, z.core.$loose>;
+type SearchResult = z.infer<typeof SearchResult>;
+declare const SearchResultCompact: z.ZodObject<{
+  name: z.ZodString;
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  model: z.ZodEnum<{
+    card: "card";
+    collection: "collection";
+    dashboard: "dashboard";
+    database: "database";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    segment: "segment";
+    table: "table";
+    transform: "transform";
+    exploration: "exploration";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>;
+  table_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  database_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  table_schema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  dashboard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodNumber;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type SearchResultCompact = z.infer<typeof SearchResultCompact>;
+//#endregion
+export { SearchResultCompact as i, SearchModel as n, SearchResult as r, SEARCH_MODELS as t };

package/dist/segment-D2i34X9l.d.ts

@@ -0,0 +1,16 @@
+import { f as RequestOptions, h as Transport } from "./transport-E0ZaPNWJ.js";
+import { t as ListResult } from "./list-BT_bBm9Z.js";
+import { i as SegmentUpdateInput, r as SegmentCreateInput, t as Segment } from "./segment-pj3wklGe.js";
+//#region src/resources/segment.d.ts
+interface SegmentArchiveParams {
+  revision_message: string;
+}
+declare function segmentResource(transport: Transport): {
+  list: (options?: RequestOptions) => Promise<ListResult<Segment>>;
+  get: (id: number, options?: RequestOptions) => Promise<Segment>;
+  create: (params: SegmentCreateInput, options?: RequestOptions) => Promise<Segment>;
+  update: (id: number, params: SegmentUpdateInput, options?: RequestOptions) => Promise<Segment>;
+  archive: (id: number, params: SegmentArchiveParams, options?: RequestOptions) => Promise<Segment>;
+};
+//#endregion
+export { segmentResource as n, SegmentArchiveParams as t };

package/dist/segment-pj3wklGe.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+//#region src/domain/segment.d.ts
+declare const Segment: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  description: z.ZodNullable<z.ZodString>;
+  archived: z.ZodBoolean;
+  table_id: z.ZodNumber;
+  definition: z.ZodUnknown;
+  creator_id: z.ZodNumber;
+  entity_id: z.ZodNullable<z.ZodString>;
+  show_in_getting_started: z.ZodNullable<z.ZodBoolean>;
+  caveats: z.ZodNullable<z.ZodString>;
+  points_of_interest: z.ZodNullable<z.ZodString>;
+  definition_description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  created_at: z.ZodString;
+  updated_at: z.ZodString;
+}, z.core.$loose>;
+type Segment = z.infer<typeof Segment>;
+declare const SegmentCompact: z.ZodObject<{
+  name: z.ZodString;
+  id: z.ZodNumber;
+  description: z.ZodNullable<z.ZodString>;
+  archived: z.ZodBoolean;
+  table_id: z.ZodNumber;
+}, z.core.$strip>;
+type SegmentCompact = z.infer<typeof SegmentCompact>;
+declare const SegmentCreateInput: z.ZodObject<{
+  name: z.ZodString;
+  table_id: z.ZodNumber;
+  definition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+type SegmentCreateInput = z.infer<typeof SegmentCreateInput>;
+declare const SegmentUpdateInput: z.ZodObject<{
+  name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  definition: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  revision_message: z.ZodString;
+  archived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  caveats: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  points_of_interest: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  show_in_getting_started: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$loose>;
+type SegmentUpdateInput = z.infer<typeof SegmentUpdateInput>;
+//#endregion
+export { SegmentUpdateInput as i, SegmentCompact as n, SegmentCreateInput as r, Segment as t };

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+//#region src/domain/session-properties.d.ts
+declare const TokenFeatures: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+type TokenFeatures = z.infer<typeof TokenFeatures>;
+declare const SessionProperties: z.ZodObject<{
+  version: z.ZodObject<{
+    tag: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+    hash: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>;
+  "token-features": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$loose>;
+type SessionProperties = z.infer<typeof SessionProperties>;
+//#endregion
+export { TokenFeatures as n, SessionProperties as t };

package/dist/setting-DXuQGXGF.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+//#region src/domain/setting.d.ts
+declare const Setting: z.ZodObject<{
+  key: z.ZodString;
+  value: z.ZodUnknown;
+  is_env_setting: z.ZodBoolean;
+  env_name: z.ZodString;
+  description: z.ZodString;
+  default: z.ZodUnknown;
+}, z.core.$loose>;
+type Setting = z.infer<typeof Setting>;
+declare const SettingCompact: z.ZodObject<{
+  value: z.ZodUnknown;
+  key: z.ZodString;
+  is_env_setting: z.ZodBoolean;
+  env_name: z.ZodString;
+}, z.core.$strip>;
+type SettingCompact = z.infer<typeof SettingCompact>;
+declare const SettingValue: z.ZodObject<{
+  key: z.ZodString;
+  value: z.ZodUnknown;
+}, z.core.$strip>;
+type SettingValue = z.infer<typeof SettingValue>;
+//#endregion
+export { SettingCompact as n, SettingValue as r, Setting as t };

package/dist/setup-Ez_U7GmM.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+//#region src/domain/setup.d.ts
+declare const SetupInput: z.ZodObject<{
+  token: z.ZodString;
+  user: z.ZodObject<{
+    first_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    last_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodEmail;
+    password: z.ZodString;
+  }, z.core.$loose>;
+  prefs: z.ZodObject<{
+    site_name: z.ZodString;
+    site_locale: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type SetupInput = z.infer<typeof SetupInput>;
+declare const SetupResult: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$loose>;
+type SetupResult = z.infer<typeof SetupResult>;
+declare const SetupResultCompact: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+type SetupResultCompact = z.infer<typeof SetupResultCompact>;
+//#endregion
+export { SetupResult as n, SetupResultCompact as r, SetupInput as t };

package/dist/signal.d.ts

@@ -0,0 +1,8 @@
+import { X as MetabaseError } from "./transport-E0ZaPNWJ.js";
+//#region src/signal.d.ts
+declare function combineAborts(...signals: Array<AbortSignal | undefined>): AbortSignal;
+declare function throwIfAborted(...signals: Array<AbortSignal | undefined>): void;
+declare function abortReason(signal: AbortSignal): MetabaseError;
+declare function untilAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+//#endregion
+export { abortReason, combineAborts, throwIfAborted, untilAborted };