@metabase/client 0.0.0-stage → 0.1.1

package/dist/resources/collection.js

@@ -0,0 +1,134 @@
+import { Collection, CollectionItem, CollectionTreeNode } from "../domain/collection.js";
+import { paginatePages } from "../paginate.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { z } from "zod";
+//#region src/resources/collection.ts
+const CollectionApiList = z.array(Collection);
+const CollectionTreeApiList = z.array(CollectionTreeNode);
+const COLLECTION_LIST_QUERY = {
+	all: {},
+	archived: { archived: true },
+	personal: { "personal-only": true }
+};
+const DEFAULT_LIST_FILTER = "all";
+const TRASH_ALIAS = "trash";
+const MODELS_FIELDS = ["models"];
+const ITEM_MODEL_FEATURES = {
+	transform: "transforms",
+	measure: "collectionItemMeasures",
+	exploration: "explorations"
+};
+function itemModelFeatures(_ref, params = {}) {
+	if (params.models === void 0) return [];
+	return params.models.flatMap((model) => {
+		const feature = ITEM_MODEL_FEATURES[model];
+		return feature === void 0 ? [] : [{
+			feature,
+			fields: MODELS_FIELDS
+		}];
+	});
+}
+function refPath(ref) {
+	return encodeURIComponent(ref);
+}
+/**
+* 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.
+*/
+async function listCollectionsAs(transport, schema, options = {}) {
+	return transport.requestParsed(z.array(schema), "/api/collection", { ...options });
+}
+function collectionResource(transport) {
+	const { explainWalk } = explainer(transport, "collection");
+	/**
+	* List collections. `filter` picks a server-side preset: everything, archived, or personal. Every
+	* preset includes the Library collections that match it. `namespace` lists that namespace's
+	* collections, with its root, instead of the default namespace's.
+	*/
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(CollectionApiList, "/api/collection", {
+				...options,
+				query: {
+					...COLLECTION_LIST_QUERY[params.filter ?? DEFAULT_LIST_FILTER],
+					namespace: params.namespace
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one collection by id, entity id, or the `root`/`trash` alias. */
+	async function get(ref, options = {}) {
+		return transport.requestParsed(Collection, `/api/collection/${refPath(ref)}`, { ...options });
+	}
+	/** Create a new collection. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Collection, "/api/collection", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a collection, patching the fields the body carries. The server reads an absent
+	* `archived` as `false`, so a patch without it restores an archived collection, and a patch that
+	* moves a collection into the trash ignores `parent_id`.
+	*/
+	async function update(ref, params, options = {}) {
+		return transport.requestParsed(Collection, `/api/collection/${refPath(ref)}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Archive (soft-delete) a collection. Metabase models this as an update, not its own endpoint. */
+	async function archive(ref, options = {}) {
+		return update(ref, { archived: true }, options);
+	}
+	/**
+	* Walk the items inside a collection one page at a time. This endpoint pages on the server, so
+	* the caller consumes pages rather than a single list and decides how far to pull. The `trash`
+	* alias costs one more request, which reads the trash collection's id. A `models` filter takes
+	* `transform` only with `transforms`, `measure` only with `collectionItemMeasures`, and
+	* `exploration` only with `explorations`.
+	*/
+	async function* itemPages(ref, params = {}, options = {}) {
+		const withSignal = options.signal !== void 0 && { signal: options.signal };
+		yield* paginatePages(transport, `/api/collection/${refPath(ref === TRASH_ALIAS ? (await get(TRASH_ALIAS, { ...withSignal })).id : ref)}/items`, CollectionItem, {
+			query: {
+				models: params.models,
+				archived: params.archived,
+				pinned_state: params.pinned_state,
+				"pinned-state": params.pinned_state
+			},
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...withSignal
+		});
+	}
+	/** Fetch the collection hierarchy as a forest of nested nodes. */
+	async function tree(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(CollectionTreeApiList, "/api/collection/tree", {
+				...options,
+				query: { "include-library": params["include-library"] }
+			}),
+			total: null
+		};
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive,
+		itemPages: explainWalk("itemPages", itemPages, itemModelFeatures),
+		tree
+	};
+}
+//#endregion
+export { collectionResource, listCollectionsAs };

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

@@ -0,0 +1,11 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.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 { t as explainer } from "../refusal-B9aeHMc9.js";
+import { ContentTranslationUploadResult } from "../domain/content-translation.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-CM7RmNeE.js";
+export { DashboardListParams, DashcardCardArchived, DashcardCardIssue, DashcardCardMissing, DashcardCardProblem, DashcardCardUnreadable, dashboardResource };

package/dist/resources/dashboard.js

@@ -0,0 +1,221 @@
+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, DashboardCreateInput, Dashcard, dashboardDetailSchema } from "../domain/dashboard.js";
+import { parseRequestBody } from "./request-body.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(dashboardDetailSchema, `/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. A key `DashboardCreateInput` does not declare is dropped
+	* before the request, as the server drops it.
+	*/
+	async function create(params, options = {}) {
+		const body = parseRequestBody(DashboardCreateInput, params, "dashboard");
+		return transport.requestParsed(Dashboard, "/api/dashboard", {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	/**
+	* 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(dashboardDetailSchema, `/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,60 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { a as DataActionExecuteInput, c as DataActionUpdateInput, n as DataAction, o as DataActionExecuteResult } from "../data-action-CkXVrOUH.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: DataActionUpdateInput, options?: RequestOptions) => Promise<DataAction>;
+  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 { DATA_ACTION_COLLECTION_GATE, DataActionExecuteResult, dataActionSchema } from "../domain/data-action.js";
+import { gateTriggered } from "../version/input-gates.js";
+import { z } from "zod";
+//#region src/resources/data-action.ts
+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. A server whose data
+	* actions have no collection never moves the action, and from 58.31 it strips the undeclared key and
+	* answers as if it had. So the field is refused there before the wire.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.requireFeatures(gateTriggered(DATA_ACTION_COLLECTION_GATE, params.collection_id) ? [DATA_ACTION_COLLECTION_GATE.feature] : [], 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,
+		archive,
+		delete: remove,
+		execute
+	};
+}
+//#endregion
+export { dataActionResource };

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

@@ -0,0 +1,112 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+//#region src/resources/data-app.d.ts
+declare function dataAppResource(transport: Transport): {
+  list: (filter?: {
+    available?: boolean | undefined;
+  } | undefined, options?: RequestOptions | undefined) => Promise<ListResult<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    version: number;
+    outdated: boolean;
+    bundle_path: string;
+    enabled: boolean;
+    allowed_hosts: string[];
+    resource_collection_id: number;
+    bundle_hash: string | null;
+    created_at: string;
+    updated_at: string;
+  } | {
+    name: string;
+    display_name: string;
+  }>>;
+  get: (slug: string, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    version: number;
+    outdated: boolean;
+    bundle_path: string;
+    enabled: boolean;
+    allowed_hosts: string[];
+    resource_collection_id: number;
+    bundle_hash: string | null;
+    created_at: string;
+    updated_at: string;
+  } | {
+    name: string;
+    display_name: string;
+  }>;
+  create: (params: {
+    name: string;
+    display_name?: string | undefined;
+    description?: string | null | undefined;
+    version?: number | undefined;
+    bundle_path?: string | undefined;
+    allowed_hosts?: string[] | undefined;
+    enabled?: boolean | undefined;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    version: number;
+    outdated: boolean;
+    bundle_path: string;
+    enabled: boolean;
+    allowed_hosts: string[];
+    resource_collection_id: number;
+    bundle_hash: string | null;
+    created_at: string;
+    updated_at: string;
+  }>;
+  update: (slug: string, params: {
+    display_name?: string | undefined;
+    description?: string | null | undefined;
+    version?: number | undefined;
+    bundle_path?: string | undefined;
+    allowed_hosts?: string[] | undefined;
+    enabled?: boolean | undefined;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    version: number;
+    outdated: boolean;
+    bundle_path: string;
+    enabled: boolean;
+    allowed_hosts: string[];
+    resource_collection_id: number;
+    bundle_hash: string | null;
+    created_at: string;
+    updated_at: string;
+  }>;
+  replaceBundle: (slug: string, bundle: string, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    version: number;
+    outdated: boolean;
+    bundle_path: string;
+    enabled: boolean;
+    allowed_hosts: string[];
+    resource_collection_id: number;
+    bundle_hash: string | null;
+    created_at: string;
+    updated_at: string;
+  }>;
+  typedSchema: (slug: string, options?: RequestOptions | undefined) => Promise<string>;
+  delete: (slug: string, options?: RequestOptions | undefined) => Promise<void>;
+};
+//#endregion
+export { dataAppResource };