@metabase/client 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,11 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { t as CsvFile } from "../csv-upload--K35QedP.js";
+//#region src/resources/content-translation.d.ts
+declare function contentTranslationResource(transport: Transport): {
+  download: (options?: RequestOptions | undefined) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+  upload: (file: CsvFile, options?: RequestOptions | undefined) => Promise<{
+    success: true;
+  }>;
+};
+//#endregion
+export { contentTranslationResource };

package/dist/resources/content-translation.js

@@ -0,0 +1,27 @@
+import { ContentTranslationUploadResult } from "../domain/content-translation.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { buildCsvFormData } from "./csv-upload.js";
+//#region src/resources/content-translation.ts
+const CONTENT_TRANSLATION_PATH = "/api/ee/content-translation";
+function contentTranslationResource(transport) {
+	const { explain } = explainer(transport, "contentTranslation");
+	/** Download the complete content translation dictionary as CSV. */
+	async function download(options = {}) {
+		return transport.requestStream(`${CONTENT_TRANSLATION_PATH}/csv`, options);
+	}
+	/** Replace the complete content translation dictionary with the attached CSV. */
+	async function upload(file, options = {}) {
+		const form = buildCsvFormData(file);
+		return transport.requestParsed(ContentTranslationUploadResult, `${CONTENT_TRANSLATION_PATH}/upload-dictionary`, {
+			...options,
+			method: "POST",
+			body: form
+		});
+	}
+	return {
+		download: explain("download", download),
+		upload: explain("upload", upload)
+	};
+}
+//#endregion
+export { contentTranslationResource };

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

@@ -0,0 +1,2 @@
+import { n as buildCsvFormData, t as CsvFile } from "../csv-upload--K35QedP.js";
+export { CsvFile, buildCsvFormData };

package/dist/resources/csv-upload.js

@@ -0,0 +1,9 @@
+//#region src/resources/csv-upload.ts
+const CSV_CONTENT_TYPE = "text/csv";
+function buildCsvFormData(file) {
+	const form = new FormData();
+	form.append("file", new Blob([file.bytes], { type: CSV_CONTENT_TYPE }), file.filename);
+	return form;
+}
+//#endregion
+export { buildCsvFormData };

package/dist/resources/dashboard.d.ts

@@ -0,0 +1,2 @@
+import { a as DashcardCardProblem, i as DashcardCardMissing, n as DashcardCardArchived, o as DashcardCardUnreadable, r as DashcardCardIssue, s as dashboardResource, t as DashboardListParams } from "../dashboard-XTe46250.js";
+export { DashboardListParams, DashcardCardArchived, DashcardCardIssue, DashcardCardMissing, DashcardCardProblem, DashcardCardUnreadable, dashboardResource };

package/dist/resources/dashboard.js

@@ -0,0 +1,218 @@
+import { ConfigError } from "../errors.js";
+import { a as HttpError } from "../errors-DdMlaXqq.js";
+import { ParameterValues } from "../domain/parameter.js";
+import { cardResource } from "./card.js";
+import { Dashboard, DashboardCopy, DashboardDetail, Dashcard } from "../domain/dashboard.js";
+import { z } from "zod";
+//#region src/resources/dashboard.ts
+const DashboardApiList = z.array(Dashboard);
+const PreflightDashcard = z.looseObject({ card_id: z.number().int().nullable().optional() });
+function dashboardResource(transport) {
+	const card = cardResource(transport);
+	/** List dashboards. `f` picks a server-side preset. */
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(DashboardApiList, "/api/dashboard", {
+				...options,
+				query: { f: params.f }
+			}),
+			total: null
+		};
+	}
+	/** Get one dashboard by id, with its dashcards, tabs and parameters. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, { ...options });
+	}
+	/**
+	* Create a dashboard. The endpoint accepts no dashcards or tabs — a follow-up `update` is what
+	* puts content on a fresh dashboard.
+	*/
+	async function create(params, options = {}) {
+		return transport.requestParsed(Dashboard, "/api/dashboard", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a dashboard by id, patching only the fields the body carries. `dashcards` and `tabs` are
+	* full replacements: whatever the arrays omit is deleted from the dashboard. A body with
+	* `dashcards` and no `tabs` key keeps the current tabs, read first: the server takes the missing
+	* key for an empty list and deletes every tab, or fails on a dashcard that still names one.
+	*/
+	async function update(id, params, options = {}) {
+		const body = await withCurrentTabs(id, params, options);
+		return transport.requestParsed(DashboardDetail, `/api/dashboard/${id}`, {
+			...options,
+			method: "PUT",
+			body
+		});
+	}
+	async function withCurrentTabs(id, params, options) {
+		if (params.dashcards === void 0 || params.tabs !== void 0) return params;
+		const current = await get(id, options);
+		return {
+			...params,
+			tabs: tabWrites(current.tabs)
+		};
+	}
+	/**
+	* Copy a dashboard, with its tabs and dashcards, into `collection_id` (root when absent). A deep
+	* copy duplicates its questions and metrics and references its models. With `is_deep_copy`
+	* false or absent the copy references every card, and a dashboard holding unarchived dashboard
+	* questions is refused. Archived cards, cards the caller cannot read, and every card on a
+	* dashcard whose main card the caller cannot read are left out and reported as `uncopied`, once
+	* per dashcard they sat on. A left-out main card takes its dashcard with it; a left-out series
+	* card stays on a dashcard whose main card is referenced and is dropped from one whose main card
+	* is duplicated. Action, link and placeholder dashcards are not copied.
+	*/
+	async function copy(id, params = {}, options = {}) {
+		return transport.requestParsed(DashboardCopy, `/api/dashboard/${id}/copy`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a dashboard by id. Metabase models this as an update, not its own
+	* endpoint. The answer is read as `Dashboard` rather than the `DashboardDetail` `update` returns:
+	* an archive is a state change on the dashboard itself, and its dashcards are not part of it.
+	*/
+	async function archive(id, options = {}) {
+		return transport.requestParsed(Dashboard, `/api/dashboard/${id}`, {
+			...options,
+			method: "PUT",
+			body: { archived: true }
+		});
+	}
+	/**
+	* Patch one dashcard on a dashboard. Metabase exposes no dashcard endpoint and its dashboard PUT
+	* is a full replace of `dashcards`, so the patch is read-modify-written over the dashboard as it
+	* currently stands, its tabs sent back unchanged.
+	*/
+	async function updateDashcard(dashboardId, dashcardId, params, options = {}) {
+		const dashboard = await get(dashboardId, options);
+		const target = dashboard.dashcards.find((dashcard) => dashcard.id === dashcardId);
+		if (target === void 0) throw new ConfigError(`dashcard ${dashcardId} not found on dashboard ${dashboardId}`);
+		const patched = Dashcard.parse({
+			...target,
+			...params
+		});
+		const refreshed = (await update(dashboardId, {
+			dashcards: dashboard.dashcards.map((dashcard) => stripEntityId(dashcard.id === dashcardId ? patched : dashcard)),
+			tabs: tabWrites(dashboard.tabs)
+		}, options)).dashcards.find((dashcard) => dashcard.id === dashcardId);
+		if (refreshed === void 0) throw new Error(`PUT /api/dashboard/${dashboardId}: dashcard ${dashcardId} missing from response`);
+		return refreshed;
+	}
+	/**
+	* Check every card a `dashcards` body references before writing it, through `GET /api/card/{id}`
+	* once per distinct id. Reports one issue per reference whose card is missing, archived, or
+	* unreadable, so an empty result means the body is safe to send; an id the server answers for in
+	* any other way propagates as the failure it was.
+	*/
+	async function checkCardReferences(dashcards, options = {}) {
+		const grouped = groupByCardId(collectCardReferences(dashcards));
+		return (await Promise.all(Array.from(grouped.entries()).map(async ([cardId, references]) => ({
+			references,
+			problem: await inspectCard(cardId, options)
+		})))).flatMap((check) => {
+			const problem = check.problem;
+			if (problem === null) return [];
+			return check.references.map((reference) => ({
+				...reference,
+				problem
+			}));
+		});
+	}
+	async function inspectCard(cardId, options) {
+		try {
+			return (await card.get(cardId, options)).archived ? { reason: "archived" } : null;
+		} catch (error) {
+			if (!(error instanceof HttpError)) throw error;
+			if (error.kind === "resource-missing") return { reason: "missing" };
+			if (error.kind === "auth" || error.kind === "forbidden") return {
+				reason: "unreadable",
+				detail: error.userMessage
+			};
+			throw error;
+		}
+	}
+	/**
+	* Fetch the selectable values for a dashboard parameter, through the chain-filter value endpoint.
+	* `constraints` sets other parameters' values, which narrow the values of a parameter linked to
+	* them.
+	*/
+	async function parameterValues(dashboardId, parameterId, constraints = {}, options = {}) {
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${encodeURIComponent(parameterId)}/values`, {
+			...options,
+			query: constraints
+		});
+	}
+	/**
+	* Search a dashboard parameter's selectable values: the server returns only values containing the
+	* substring, capped at the first 1000 matches. `constraints` narrows them as `parameterValues`
+	* does.
+	*/
+	async function searchParameterValues(dashboardId, parameterId, query, constraints = {}, options = {}) {
+		const parameter = encodeURIComponent(parameterId);
+		return transport.requestParsed(ParameterValues, `/api/dashboard/${dashboardId}/params/${parameter}/search/${encodeURIComponent(query)}`, {
+			...options,
+			query: constraints
+		});
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive,
+		copy,
+		updateDashcard,
+		checkCardReferences,
+		parameterValues,
+		searchParameterValues
+	};
+}
+function collectCardReferences(dashcards) {
+	if (dashcards === void 0 || dashcards === null) return [];
+	const references = [];
+	dashcards.forEach((dashcard, index) => {
+		const parsed = PreflightDashcard.safeParse(dashcard);
+		if (!parsed.success) return;
+		const cardId = parsed.data.card_id;
+		if (typeof cardId === "number" && cardId > 0) references.push({
+			cardId,
+			path: `/dashcards/${index}/card_id`
+		});
+	});
+	return references;
+}
+function groupByCardId(references) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		const existing = grouped.get(reference.cardId);
+		if (existing === void 0) grouped.set(reference.cardId, [reference]);
+		else existing.push(reference);
+	}
+	return grouped;
+}
+function tabWrites(tabs) {
+	return tabs.map(({ id, name }) => ({
+		id,
+		name
+	}));
+}
+function stripEntityId(dashcard) {
+	const { entity_id: _entity_id, id, size_x, size_y, row, col, ...rest } = dashcard;
+	return {
+		...rest,
+		id,
+		size_x,
+		size_y,
+		row,
+		col
+	};
+}
+//#endregion
+export { dashboardResource };

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

@@ -0,0 +1,105 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { a as DataActionExecuteResult, i as DataActionExecuteInput, t as DataAction } from "../data-action-rS27f2Ji.js";
+//#region src/resources/data-action.d.ts
+declare function dataActionResource(transport: Transport): {
+  list: (options?: RequestOptions) => Promise<ListResult<DataAction>>;
+  get: (id: number, options?: RequestOptions) => Promise<DataAction>;
+  create: (params: {
+    name: string;
+    type: "query";
+    database_id: number;
+    dataset_query: {
+      [x: string]: unknown;
+    };
+    parameters?: {
+      [x: string]: unknown;
+      id: string;
+      type: string;
+      target: unknown;
+      name?: string | undefined;
+      slug?: string | undefined;
+      required?: boolean | undefined;
+    }[] | undefined;
+    collection_id?: number | null | undefined;
+    description?: string | null | undefined;
+    visualization_settings?: unknown;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    description: string | null;
+    type: string;
+    model_id: number | null;
+    parameters: {
+      [x: string]: unknown;
+      id: string;
+      type: string;
+      name?: string | undefined;
+      slug?: string | undefined;
+      target?: unknown;
+      required?: boolean | undefined;
+    }[] | null;
+    visualization_settings: unknown;
+    archived: boolean;
+    public_uuid: string | null;
+    entity_id: string | null;
+    creator_id: number;
+    created_at: string;
+    updated_at: string;
+    collection_id: number | null;
+    database_id?: number | null | undefined;
+    dataset_query?: unknown;
+  }>;
+  update: (id: number, params: {
+    name?: string | undefined;
+    database_id?: number | undefined;
+    dataset_query?: {
+      [x: string]: unknown;
+    } | undefined;
+    parameters?: {
+      [x: string]: unknown;
+      id: string;
+      type: string;
+      target: unknown;
+      name?: string | undefined;
+      slug?: string | undefined;
+      required?: boolean | undefined;
+    }[] | undefined;
+    collection_id?: number | null | undefined;
+    description?: string | null | undefined;
+    visualization_settings?: unknown;
+    archived?: boolean | undefined;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    description: string | null;
+    type: string;
+    model_id: number | null;
+    parameters: {
+      [x: string]: unknown;
+      id: string;
+      type: string;
+      name?: string | undefined;
+      slug?: string | undefined;
+      target?: unknown;
+      required?: boolean | undefined;
+    }[] | null;
+    visualization_settings: unknown;
+    archived: boolean;
+    public_uuid: string | null;
+    entity_id: string | null;
+    creator_id: number;
+    created_at: string;
+    updated_at: string;
+    collection_id: number | null;
+    database_id?: number | null | undefined;
+    dataset_query?: unknown;
+  }>;
+  archive: (id: number, options?: RequestOptions) => Promise<DataAction>;
+  delete: (id: number, options?: RequestOptions) => Promise<void>;
+  execute: (id: number, params: DataActionExecuteInput, options?: RequestOptions) => Promise<DataActionExecuteResult>;
+};
+//#endregion
+export { dataActionResource };

package/dist/resources/data-action.js

@@ -0,0 +1,79 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { DataActionExecuteResult, dataActionSchema } from "../domain/data-action.js";
+import { z } from "zod";
+//#region src/resources/data-action.ts
+function collectionFeatures(params) {
+	return params.collection_id === void 0 ? [] : [{
+		feature: "dataActionCollections",
+		fields: ["collection_id"]
+	}];
+}
+function dataActionResource(transport) {
+	const { explain } = explainer(transport, "dataAction");
+	async function readSchema(options) {
+		const { features } = await transport.server(options);
+		return dataActionSchema(features);
+	}
+	/** List the unarchived data actions the caller can see. `GET /api/action` answers a bare array. */
+	async function list(options = {}) {
+		const schema = await readSchema(options);
+		return {
+			data: await transport.requestParsed(z.array(schema), "/api/action", { ...options }),
+			total: null
+		};
+	}
+	/** Get one unarchived data action by id. */
+	async function get(id, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, `/api/action/${id}`, { ...options });
+	}
+	/** Create a data action — a parameterized native query that writes to a database — in a collection. */
+	async function create(params, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, "/api/action", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a data action by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		const schema = await readSchema(options);
+		return transport.requestParsed(schema, `/api/action/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a data action by id. Metabase models this as an update, not its own endpoint. */
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	/** Delete a data action by id, removing it and the dashboard buttons that run it. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/action/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** Execute a data action by id with parameter values keyed by parameter id. */
+	async function execute(id, params, options = {}) {
+		return transport.requestParsed(DataActionExecuteResult, `/api/action/${id}/execute`, {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		list,
+		get,
+		create: explain("create", create),
+		update: explain("update", update, (_id, params) => collectionFeatures(params)),
+		archive,
+		delete: remove,
+		execute
+	};
+}
+//#endregion
+export { dataActionResource };

package/dist/resources/database.d.ts

@@ -0,0 +1,2 @@
+import { i as databaseResource, n as DatabaseListParams, r as DatabaseSyncSchemaParams, t as DatabaseGetParams } from "../database-DqTespfa.js";
+export { DatabaseGetParams, DatabaseListParams, DatabaseSyncSchemaParams, databaseResource };

package/dist/resources/database.js

@@ -0,0 +1,103 @@
+import { Table } from "../domain/table.js";
+import { Database, DatabaseWithSettings } from "../domain/database.js";
+import { pollUntil } from "../poll.js";
+import { z } from "zod";
+//#region src/resources/database.ts
+const DatabaseApiList = z.object({
+	data: z.array(Database),
+	total: z.number().int().nonnegative()
+}).loose();
+const DatabaseTaskAck = z.object({ status: z.literal("ok") });
+const DatabaseApiSchemaList = z.array(z.string());
+const DatabaseApiSchemaTableList = z.array(Table);
+const SYNC_COMPLETE = "complete";
+function databaseResource(transport) {
+	/** List databases. `include` hydrates each database's tables; `saved` adds the Saved Questions virtual database. */
+	async function list(params = {}, options = {}) {
+		const response = await transport.requestParsed(DatabaseApiList, "/api/database", {
+			...options,
+			query: {
+				include: params.include,
+				saved: params.saved
+			}
+		});
+		return {
+			data: response.data,
+			total: response.total
+		};
+	}
+	/** Get one database by id. `include` hydrates its tables, and `tables.fields` their fields too. */
+	async function get(id, params = {}, options = {}) {
+		return transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			query: { include: params.include }
+		});
+	}
+	/** Update a database's settings by id; the server merges them into the ones it holds. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(DatabaseWithSettings, `/api/database/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** List the schema names in a database. */
+	async function schemas(id, options = {}) {
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaList, `/api/database/${id}/schemas`, { ...options }),
+			total: null
+		};
+	}
+	/** List the tables one schema of a database holds. */
+	async function schemaTables(id, schema, options = {}) {
+		return {
+			data: await transport.requestParsed(DatabaseApiSchemaTableList, `/api/database/${id}/schema/${encodeURIComponent(schema)}`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Trigger a manual schema sync for a database. The endpoint queues the sync and returns at once;
+	* pass `wait` to poll the database until it reports its initial sync complete.
+	*/
+	async function syncSchema(id, params = {}, options = {}) {
+		const ack = await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/sync_schema`, {
+			...options,
+			method: "POST"
+		});
+		const wait = params.wait;
+		if (wait === void 0) return {
+			id,
+			status: ack.status
+		};
+		const database = await pollUntil(async (signal) => transport.requestParsed(Database, `/api/database/${id}`, {
+			...options,
+			signal
+		}), (candidate) => candidate.initial_sync_status === SYNC_COMPLETE, wait);
+		return {
+			id,
+			status: ack.status,
+			initial_sync_status: database.initial_sync_status ?? null
+		};
+	}
+	/** Trigger a rescan of the cached field values across a database. */
+	async function rescanValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(DatabaseTaskAck, `/api/database/${id}/rescan_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	return {
+		list,
+		get,
+		update,
+		schemas,
+		schemaTables,
+		syncSchema,
+		rescanValues
+	};
+}
+//#endregion
+export { databaseResource };

package/dist/resources/dataset.d.ts

@@ -0,0 +1,2 @@
+import { n as DatasetNativeParams, r as datasetResource, t as DatasetExportParams } from "../dataset-Cj3XuKLe.js";
+export { DatasetExportParams, DatasetNativeParams, datasetResource };

package/dist/resources/dataset.js

@@ -0,0 +1,81 @@
+import { CardQueryResult } from "../domain/card.js";
+import { CompiledQuery, QueryMetadata } from "../domain/dataset.js";
+import { assertPivotedExport } from "./pivot-export.js";
+//#region src/resources/dataset.ts
+function datasetResource(transport) {
+	/**
+	* Run an ad-hoc query and return its result envelope. The body is a whole query — MBQL 5, legacy
+	* MBQL, or native — rather than a reference to a saved one, so nothing here is a card.
+	*/
+	async function query(body, options = {}) {
+		return transport.requestParsed(CardQueryResult, "/api/dataset", {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	/**
+	* Fetch a native version of an MBQL query. `pretty` rides in the same body as the query and
+	* defaults server-side to true.
+	*/
+	async function native(datasetQuery, params = {}, options = {}) {
+		return transport.requestParsed(CompiledQuery, "/api/dataset/native", {
+			...options,
+			method: "POST",
+			body: {
+				...datasetQuery,
+				pretty: params.pretty
+			}
+		});
+	}
+	/**
+	* Get all of the required query metadata for an ad-hoc query: the databases, tables, fields and
+	* snippets it references. `{ settings: { "include-sensitive-fields": true } }` inside the query
+	* widens the field filter.
+	*/
+	async function queryMetadata(datasetQuery, options = {}) {
+		return transport.requestParsed(QueryMetadata, "/api/dataset/query_metadata", {
+			...options,
+			method: "POST",
+			body: datasetQuery
+		});
+	}
+	/**
+	* Execute a query and download the result data as a file in the specified format. Unlike
+	* `query`, this endpoint answers bytes, so a caller consumes the stream rather than a value.
+	* `visualization_settings` drive `format_rows` column formatting and, through
+	* `pivot_table.column_split`, the layout `pivot_results` lays the rows out in. The server only
+	* computes that layout for a query it runs as a pivot, which it reads from the query's own
+	* `was-pivot`, so `pivot_results` sets it. A pivot the server would answer with plain rows (a
+	* JSON export, or pivoted exports turned off) is refused. `csv_include_bom` opens a CSV with a
+	* UTF-8 byte order mark; a server without it drops the key silently, so asking for one is refused
+	* there before the wire.
+	*/
+	async function exportQuery(format, params, options = {}) {
+		if (params.pivot_results) await assertPivotedExport(transport, format, options);
+		await transport.requireFeatures(params.csv_include_bom ? ["exportCsvByteOrderMark"] : [], options);
+		const exported = params.pivot_results ? {
+			...params.query,
+			"was-pivot": true
+		} : params.query;
+		return transport.requestStream(`/api/dataset/${format}`, {
+			...options,
+			method: "POST",
+			body: {
+				query: exported,
+				visualization_settings: params.visualization_settings,
+				format_rows: params.format_rows,
+				pivot_results: params.pivot_results,
+				csv_include_bom: params.csv_include_bom
+			}
+		});
+	}
+	return {
+		query,
+		native,
+		queryMetadata,
+		exportQuery
+	};
+}
+//#endregion
+export { datasetResource };

package/dist/resources/dependency.d.ts

@@ -0,0 +1,2 @@
+import { a as dependencyResource, i as DependencyItemPageOptions, n as DependencyDependentsParams, r as DependencyItemListParams, t as DependencyBrokenParams } from "../dependency-fN5_7a22.js";
+export { DependencyBrokenParams, DependencyDependentsParams, DependencyItemListParams, DependencyItemPageOptions, dependencyResource };