@metabase/client 0.0.0-stage → 0.1.1

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import { n as createClient, t as MetabaseClient } from "./client-DdXLlH1B.js";
+export { MetabaseClient, createClient };

package/dist/client.js

@@ -0,0 +1,99 @@
+import { r as createTransport } from "./transport-HP7cyo9N.js";
+import { apiKeyResource } from "./resources/api-key.js";
+import { cardResource } from "./resources/card.js";
+import { collectionResource } from "./resources/collection.js";
+import { contentTranslationResource } from "./resources/content-translation.js";
+import { dashboardResource } from "./resources/dashboard.js";
+import { dataActionResource } from "./resources/data-action.js";
+import { dataAppResource } from "./resources/data-app.js";
+import { databaseResource } from "./resources/database.js";
+import { datasetResource } from "./resources/dataset.js";
+import { dependencyResource } from "./resources/dependency.js";
+import { documentResource } from "./resources/document.js";
+import { eidTranslationResource } from "./resources/eid-translation.js";
+import { erdResource } from "./resources/erd.js";
+import { fieldResource } from "./resources/field.js";
+import { gitSyncResource } from "./resources/git-sync.js";
+import { glossaryResource } from "./resources/glossary.js";
+import { libraryResource } from "./resources/library.js";
+import { measureResource } from "./resources/measure.js";
+import { metricResource } from "./resources/metric.js";
+import { moderationReviewResource } from "./resources/moderation-review.js";
+import { notificationResource } from "./resources/notification.js";
+import { permissionResource } from "./resources/permission.js";
+import { pulseResource } from "./resources/pulse.js";
+import { replacementResource } from "./resources/replacement.js";
+import { revisionResource } from "./resources/revision.js";
+import { searchResource } from "./resources/search.js";
+import { segmentResource } from "./resources/segment.js";
+import { settingResource } from "./resources/setting.js";
+import { setupResource } from "./resources/setup.js";
+import { snippetResource } from "./resources/snippet.js";
+import { tableResource } from "./resources/table.js";
+import { timelineEventResource } from "./resources/timeline-event.js";
+import { timelineResource } from "./resources/timeline.js";
+import { transformDagRunResource } from "./resources/transform-dag-run.js";
+import { transformInspectorResource } from "./resources/transform-inspector.js";
+import { transformJobResource } from "./resources/transform-job.js";
+import { transformPythonResource } from "./resources/transform-python.js";
+import { transformResource } from "./resources/transform.js";
+import { transformTagResource } from "./resources/transform-tag.js";
+import { transformTestResource } from "./resources/transform-test.js";
+import { uploadResource } from "./resources/upload.js";
+import { userResource } from "./resources/user.js";
+//#region src/client.ts
+function createClient(config, options) {
+	const transport = createTransport(config, options);
+	return {
+		apiKey: apiKeyResource(transport),
+		card: cardResource(transport),
+		collection: collectionResource(transport),
+		contentTranslation: contentTranslationResource(transport),
+		dashboard: dashboardResource(transport),
+		dataAction: dataActionResource(transport),
+		dataApp: dataAppResource(transport),
+		database: databaseResource(transport),
+		dataset: datasetResource(transport),
+		dependency: dependencyResource(transport),
+		document: documentResource(transport),
+		eidTranslation: eidTranslationResource(transport),
+		erd: erdResource(transport),
+		field: fieldResource(transport),
+		gitSync: gitSyncResource(transport),
+		glossary: glossaryResource(transport),
+		library: libraryResource(transport),
+		measure: measureResource(transport),
+		metric: metricResource(transport),
+		moderationReview: moderationReviewResource(transport),
+		notification: notificationResource(transport),
+		permission: permissionResource(transport),
+		pulse: pulseResource(transport),
+		replacement: replacementResource(transport),
+		revision: revisionResource(transport),
+		search: searchResource(transport),
+		segment: segmentResource(transport),
+		setting: settingResource(transport),
+		setup: setupResource(transport),
+		snippet: snippetResource(transport),
+		table: tableResource(transport),
+		timeline: timelineResource(transport),
+		timelineEvent: timelineEventResource(transport),
+		transform: transformResource(transport),
+		transformDagRun: transformDagRunResource(transport),
+		transformInspector: transformInspectorResource(transport),
+		transformJob: transformJobResource(transport),
+		transformPython: transformPythonResource(transport),
+		transformTag: transformTagResource(transport),
+		transformTest: transformTestResource(transport),
+		upload: uploadResource(transport),
+		user: userResource(transport),
+		server: transport.server,
+		verifiedServer: transport.verifiedServer,
+		probesSettled: transport.probesSettled,
+		requestParsed: transport.requestParsed,
+		requestRaw: transport.requestRaw,
+		requestStream: transport.requestStream
+	};
+}
+//#endregion
+export { createClient };

package/dist/collection-DGnTvD6R.d.ts

@@ -0,0 +1,294 @@
+import { z } from "zod";
+//#region src/domain/collection.d.ts
+declare const CollectionId: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+type CollectionId = z.infer<typeof CollectionId>;
+declare const CollectionAuthorityLevel: z.ZodEnum<{
+  official: "official";
+}>;
+type CollectionAuthorityLevel = z.infer<typeof CollectionAuthorityLevel>;
+declare const CollectionType: z.ZodEnum<{
+  library: "library";
+  "instance-analytics": "instance-analytics";
+  trash: "trash";
+  "library-data": "library-data";
+  "library-metrics": "library-metrics";
+  "library-dashboards": "library-dashboards";
+  "tenant-specific-root-collection": "tenant-specific-root-collection";
+}>;
+type CollectionType = z.infer<typeof CollectionType>;
+declare const CollectionNamespace: z.ZodEnum<{
+  "data-apps": "data-apps";
+  transforms: "transforms";
+  snippets: "snippets";
+  analytics: "analytics";
+  "shared-tenant-collection": "shared-tenant-collection";
+  "tenant-specific": "tenant-specific";
+  "data-actions": "data-actions";
+}>;
+type CollectionNamespace = z.infer<typeof CollectionNamespace>;
+declare const CollectionListFilter: z.ZodEnum<{
+  archived: "archived";
+  all: "all";
+  personal: "personal";
+}>;
+type CollectionListFilter = z.infer<typeof CollectionListFilter>;
+declare const COLLECTION_ITEM_FILTER_MODELS: readonly ["card", "dataset", "metric", "dashboard", "snippet", "collection", "document", "exploration", "table", "transform", "measure", "pulse", "timeline", "no_models"];
+declare const CollectionItemFilterModel: z.ZodEnum<{
+  transform: "transform";
+  collection: "collection";
+  card: "card";
+  dashboard: "dashboard";
+  dataset: "dataset";
+  document: "document";
+  metric: "metric";
+  measure: "measure";
+  pulse: "pulse";
+  snippet: "snippet";
+  table: "table";
+  timeline: "timeline";
+  exploration: "exploration";
+  no_models: "no_models";
+}>;
+type CollectionItemFilterModel = z.infer<typeof CollectionItemFilterModel>;
+declare const COLLECTION_ITEM_MODELS: readonly ["card", "dataset", "metric", "dashboard", "snippet", "collection", "document", "exploration", "table", "transform", "measure", "pulse", "timeline", "no_models", "indexed-entity", "action"];
+declare const CollectionItemModel: z.ZodEnum<{
+  transform: "transform";
+  collection: "collection";
+  card: "card";
+  dashboard: "dashboard";
+  dataset: "dataset";
+  document: "document";
+  metric: "metric";
+  measure: "measure";
+  pulse: "pulse";
+  snippet: "snippet";
+  table: "table";
+  timeline: "timeline";
+  exploration: "exploration";
+  no_models: "no_models";
+  "indexed-entity": "indexed-entity";
+  action: "action";
+}>;
+type CollectionItemModel = z.infer<typeof CollectionItemModel>;
+declare const COLLECTION_PINNED_STATES: readonly ["all", "is_pinned", "is_not_pinned"];
+declare const CollectionPinnedState: z.ZodEnum<{
+  all: "all";
+  is_pinned: "is_pinned";
+  is_not_pinned: "is_not_pinned";
+}>;
+type CollectionPinnedState = z.infer<typeof CollectionPinnedState>;
+declare const Collection: z.ZodObject<{
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodOptional<z.ZodBoolean>;
+  location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  parent_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+  personal_owner_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  is_personal: z.ZodOptional<z.ZodBoolean>;
+  authority_level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    official: "official";
+  }>>>;
+  type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    library: "library";
+    "instance-analytics": "instance-analytics";
+    trash: "trash";
+    "library-data": "library-data";
+    "library-metrics": "library-metrics";
+    "library-dashboards": "library-dashboards";
+    "tenant-specific-root-collection": "tenant-specific-root-collection";
+  }>>>;
+  namespace: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    "data-apps": "data-apps";
+    transforms: "transforms";
+    snippets: "snippets";
+    analytics: "analytics";
+    "shared-tenant-collection": "shared-tenant-collection";
+    "tenant-specific": "tenant-specific";
+    "data-actions": "data-actions";
+  }>>>;
+  entity_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  slug: z.ZodOptional<z.ZodString>;
+  can_write: z.ZodOptional<z.ZodBoolean>;
+  is_remote_synced: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$loose>;
+type Collection = z.infer<typeof Collection>;
+declare const CollectionCompact: z.ZodObject<{
+  type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    library: "library";
+    "instance-analytics": "instance-analytics";
+    trash: "trash";
+    "library-data": "library-data";
+    "library-metrics": "library-metrics";
+    "library-dashboards": "library-dashboards";
+    "tenant-specific-root-collection": "tenant-specific-root-collection";
+  }>>>;
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodOptional<z.ZodBoolean>;
+  location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  authority_level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    official: "official";
+  }>>>;
+  is_personal: z.ZodOptional<z.ZodBoolean>;
+  is_remote_synced: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  parent_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+  namespace: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    "data-apps": "data-apps";
+    transforms: "transforms";
+    snippets: "snippets";
+    analytics: "analytics";
+    "shared-tenant-collection": "shared-tenant-collection";
+    "tenant-specific": "tenant-specific";
+    "data-actions": "data-actions";
+  }>>>;
+}, z.core.$strip>;
+type CollectionCompact = z.infer<typeof CollectionCompact>;
+declare const CollectionItem: z.ZodObject<{
+  id: z.ZodNumber;
+  model: z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    snippet: "snippet";
+    table: "table";
+    timeline: "timeline";
+    exploration: "exploration";
+    no_models: "no_models";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodNullable<z.ZodBoolean>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+  collection_position: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  display: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  entity_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  database_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  dashboard_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$loose>;
+type CollectionItem = z.infer<typeof CollectionItem>;
+declare const CollectionItemCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodNullable<z.ZodBoolean>;
+  collection_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+  model: z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    snippet: "snippet";
+    table: "table";
+    timeline: "timeline";
+    exploration: "exploration";
+    no_models: "no_models";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>;
+}, z.core.$strip>;
+type CollectionItemCompact = z.infer<typeof CollectionItemCompact>;
+declare const CollectionTreeNodeBase: z.ZodObject<{
+  id: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  archived: z.ZodOptional<z.ZodBoolean>;
+  location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    library: "library";
+    "instance-analytics": "instance-analytics";
+    trash: "trash";
+    "library-data": "library-data";
+    "library-metrics": "library-metrics";
+    "library-dashboards": "library-dashboards";
+    "tenant-specific-root-collection": "tenant-specific-root-collection";
+  }>>>;
+  authority_level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    official: "official";
+  }>>>;
+  here: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    snippet: "snippet";
+    table: "table";
+    timeline: "timeline";
+    exploration: "exploration";
+    no_models: "no_models";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>>>;
+  below: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    snippet: "snippet";
+    table: "table";
+    timeline: "timeline";
+    exploration: "exploration";
+    no_models: "no_models";
+    "indexed-entity": "indexed-entity";
+    action: "action";
+  }>>>;
+}, z.core.$loose>;
+type CollectionTreeNode = z.infer<typeof CollectionTreeNodeBase> & {
+  children: CollectionTreeNode[];
+};
+declare const CollectionTreeNode: z.ZodType<CollectionTreeNode>;
+declare const CollectionCreateInput: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  parent_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  namespace: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    "data-apps": "data-apps";
+    transforms: "transforms";
+    snippets: "snippets";
+    analytics: "analytics";
+    "shared-tenant-collection": "shared-tenant-collection";
+    "tenant-specific": "tenant-specific";
+    "data-actions": "data-actions";
+  }>>>;
+  authority_level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    official: "official";
+  }>>>;
+}, z.core.$loose>;
+type CollectionCreateInput = z.infer<typeof CollectionCreateInput>;
+declare const CollectionUpdateInput: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  parent_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  authority_level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    official: "official";
+  }>>>;
+  archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type CollectionUpdateInput = z.infer<typeof CollectionUpdateInput>;
+//#endregion
+export { CollectionType as _, CollectionAuthorityLevel as a, CollectionId as c, CollectionItemFilterModel as d, CollectionItemModel as f, CollectionTreeNode as g, CollectionPinnedState as h, Collection as i, CollectionItem as l, CollectionNamespace as m, COLLECTION_ITEM_MODELS as n, CollectionCompact as o, CollectionListFilter as p, COLLECTION_PINNED_STATES as r, CollectionCreateInput as s, COLLECTION_ITEM_FILTER_MODELS as t, CollectionItemCompact as u, CollectionUpdateInput as v };

package/dist/collection-fFahL-ub.d.ts

@@ -0,0 +1,53 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+import { t as ListResult } from "./list-BT_bBm9Z.js";
+import { n as Page, r as PaginateOptions } from "./paginate-COuL0Gzl.js";
+import { c as CollectionId, d as CollectionItemFilterModel, g as CollectionTreeNode, h as CollectionPinnedState, i as Collection, m as CollectionNamespace, p as CollectionListFilter, s as CollectionCreateInput, v as CollectionUpdateInput } from "./collection-DGnTvD6R.js";
+import { z } from "zod";
+//#region src/resources/collection.d.ts
+interface CollectionListParams {
+  filter?: CollectionListFilter | undefined;
+  namespace?: CollectionNamespace | undefined;
+}
+interface CollectionItemListParams {
+  models?: CollectionItemFilterModel[] | undefined;
+  archived?: boolean | undefined;
+  pinned_state?: CollectionPinnedState | undefined;
+}
+interface CollectionTreeParams {
+  /** Include the Library collections, which the tree leaves out by default. */
+  "include-library"?: boolean | undefined;
+}
+type CollectionItemPageOptions = Omit<PaginateOptions, "query">;
+/**
+ * List every collection the caller can read, the Library and its children among them, parsing each
+ * through the caller's own projection. `Collection` pins `type`, `namespace` and `authority_level`
+ * to closed enums, so a consumer reading a few fields off every collection on the instance narrows
+ * here: one collection carrying a server value outside those sets then costs nothing to a caller
+ * that never reads the field.
+ */
+declare function listCollectionsAs<T>(transport: Transport, schema: z.ZodType<T>, options?: RequestOptions): Promise<T[]>;
+declare function collectionResource(transport: Transport): {
+  list: (params?: CollectionListParams, options?: RequestOptions) => Promise<ListResult<Collection>>;
+  get: (ref: CollectionId, options?: RequestOptions) => Promise<Collection>;
+  create: (params: CollectionCreateInput, options?: RequestOptions) => Promise<Collection>;
+  update: (ref: CollectionId, params: CollectionUpdateInput, options?: RequestOptions) => Promise<Collection>;
+  archive: (ref: CollectionId, options?: RequestOptions) => Promise<Collection>;
+  itemPages: (ref: string | number, params?: CollectionItemListParams | undefined, options?: CollectionItemPageOptions | undefined) => AsyncIterable<Page<{
+    [x: string]: unknown;
+    id: number;
+    model: "transform" | "collection" | "card" | "dashboard" | "dataset" | "document" | "metric" | "measure" | "pulse" | "snippet" | "table" | "timeline" | "exploration" | "no_models" | "indexed-entity" | "action";
+    name: string;
+    archived: boolean | null;
+    description?: string | null | undefined;
+    collection_id?: string | number | null | undefined;
+    collection_position?: number | null | undefined;
+    display?: string | null | undefined;
+    location?: string | null | undefined;
+    entity_id?: string | null | undefined;
+    database_id?: number | null | undefined;
+    dashboard_id?: number | null | undefined;
+  }>>;
+  tree: (params?: CollectionTreeParams, options?: RequestOptions) => Promise<ListResult<CollectionTreeNode>>;
+};
+//#endregion
+export { collectionResource as a, CollectionTreeParams as i, CollectionItemPageOptions as n, listCollectionsAs as o, CollectionListParams as r, CollectionItemListParams as t };

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+//#region src/domain/content-translation.d.ts
+declare const ContentTranslationUploadResult: z.ZodObject<{
+  success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type ContentTranslationUploadResult = z.infer<typeof ContentTranslationUploadResult>;
+//#endregion
+export { ContentTranslationUploadResult as t };

package/dist/credential-6aOEGqMH.d.ts

@@ -0,0 +1,30 @@
+import { o as OAuthTokens } from "./oauth-C4ordeoJ.js";
+//#region src/auth/credential.d.ts
+interface ApiKeyCredential {
+  kind: "apiKey";
+  apiKey: string;
+}
+interface OAuthCredential {
+  kind: "oauth";
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+  clientId: string;
+}
+type Credential = ApiKeyCredential | OAuthCredential;
+type CredentialRefresher = () => Promise<Credential | null>;
+declare const API_KEY_HEADER = "x-api-key";
+declare const AUTHORIZATION_HEADER = "authorization";
+declare const DEFAULT_EXPIRES_IN_SECONDS = 3600;
+interface AuthHeader {
+  name: string;
+  value: string;
+}
+declare function credentialAuthHeader(credential: Credential): AuthHeader;
+declare function assertCredentialHeaderSafe(credential: Credential): void;
+declare function credentialSecrets(credential: Credential): string[];
+declare function isOAuthExpired(credential: OAuthCredential, nowMs: number): boolean;
+declare function expiresAtFromNow(expiresInSeconds: number, nowMs: number): string;
+declare function oauthCredentialFromTokens(tokens: Pick<OAuthTokens, "access_token" | "expires_in">, refreshToken: string, clientId: string, nowMs: number): OAuthCredential;
+//#endregion
+export { Credential as a, OAuthCredential as c, credentialSecrets as d, expiresAtFromNow as f, AuthHeader as i, assertCredentialHeaderSafe as l, oauthCredentialFromTokens as m, AUTHORIZATION_HEADER as n, CredentialRefresher as o, isOAuthExpired as p, ApiKeyCredential as r, DEFAULT_EXPIRES_IN_SECONDS as s, API_KEY_HEADER as t, credentialAuthHeader as u };

package/dist/cron-DThzerR6.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+//#region src/domain/cron.d.ts
+declare const CronUiDisplayType: z.ZodEnum<{
+  "cron/raw": "cron/raw";
+  "cron/builder": "cron/builder";
+}>;
+type CronUiDisplayType = z.infer<typeof CronUiDisplayType>;
+//#endregion
+export { CronUiDisplayType as t };

package/dist/csv-upload--K35QedP.d.ts

@@ -0,0 +1,8 @@
+//#region src/resources/csv-upload.d.ts
+interface CsvFile {
+  filename: string;
+  bytes: Uint8Array;
+}
+declare function buildCsvFormData(file: CsvFile): FormData;
+//#endregion
+export { buildCsvFormData as n, CsvFile as t };

package/dist/dashboard-CM7RmNeE.d.ts

@@ -0,0 +1,38 @@
+import { f as RequestOptions, h as Transport } from "./transport-BsXqRujn.js";
+import { t as ListResult } from "./list-BT_bBm9Z.js";
+import { _ as DashcardDetail, a as DashboardCopyInput, l as DashboardListFilter, m as DashboardUpdateInput, o as DashboardCreateInput, r as DashboardCopy, s as DashboardDetail, t as Dashboard, u as DashboardParameterConstraints, v as DashcardPatchInput } from "./dashboard-DtLXVgtf.js";
+import { s as ParameterValues } from "./parameter-ak-J-IOj.js";
+//#region src/resources/dashboard.d.ts
+interface DashboardListParams {
+  f?: DashboardListFilter | undefined;
+}
+interface DashcardCardMissing {
+  reason: "missing";
+}
+interface DashcardCardArchived {
+  reason: "archived";
+}
+interface DashcardCardUnreadable {
+  reason: "unreadable";
+  detail: string;
+}
+type DashcardCardProblem = DashcardCardMissing | DashcardCardArchived | DashcardCardUnreadable;
+interface DashcardCardIssue {
+  cardId: number;
+  path: string;
+  problem: DashcardCardProblem;
+}
+declare function dashboardResource(transport: Transport): {
+  list: (params?: DashboardListParams, options?: RequestOptions) => Promise<ListResult<Dashboard>>;
+  get: (id: number, options?: RequestOptions) => Promise<DashboardDetail>;
+  create: (params: DashboardCreateInput, options?: RequestOptions) => Promise<Dashboard>;
+  update: (id: number, params: DashboardUpdateInput, options?: RequestOptions) => Promise<DashboardDetail>;
+  archive: (id: number, options?: RequestOptions) => Promise<Dashboard>;
+  copy: (id: number, params?: DashboardCopyInput, options?: RequestOptions) => Promise<DashboardCopy>;
+  updateDashcard: (dashboardId: number, dashcardId: number, params: DashcardPatchInput, options?: RequestOptions) => Promise<DashcardDetail>;
+  checkCardReferences: (dashcards: ReadonlyArray<unknown> | null | undefined, options?: RequestOptions) => Promise<DashcardCardIssue[]>;
+  parameterValues: (dashboardId: number, parameterId: string, constraints?: DashboardParameterConstraints, options?: RequestOptions) => Promise<ParameterValues>;
+  searchParameterValues: (dashboardId: number, parameterId: string, query: string, constraints?: DashboardParameterConstraints, options?: RequestOptions) => Promise<ParameterValues>;
+};
+//#endregion
+export { DashcardCardProblem as a, DashcardCardMissing as i, DashcardCardArchived as n, DashcardCardUnreadable as o, DashcardCardIssue as r, dashboardResource as s, DashboardListParams as t };