@metabase/client 0.0.0-stage → 0.1.0

package/dist/resources/git-sync.js

@@ -0,0 +1,362 @@
+import { SessionProperties } from "../domain/session-properties.js";
+import { ConfigError } from "../errors.js";
+import { a as HttpError } from "../errors-DdMlaXqq.js";
+import { profileFromProperties } from "../version/probe.js";
+import { Collection } from "../domain/collection.js";
+import { listCollectionsAs } from "./collection.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { pollUntil } from "../poll.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { RemoteSyncState, SyncBranchCreated, SyncDirtyItem, SyncExportPreflight, SyncRemoteChanges, SyncSettingsUpdateResult, SyncTask, isSyncTaskTerminal } from "../domain/git-sync.js";
+import { z } from "zod";
+//#region src/resources/git-sync.ts
+const SyncScopeCollection = Collection.pick({
+	id: true,
+	name: true,
+	is_remote_synced: true
+}).strip();
+const SyncDirtyFlag = z.object({ is_dirty: z.boolean() });
+const SyncDirtyList = z.object({ dirty: z.array(SyncDirtyItem) });
+const SyncBranchList = z.object({ items: z.array(z.string()) });
+const SyncImportStarted = z.object({
+	status: z.literal("success"),
+	task_id: z.number().int().positive().nullable(),
+	message: z.string().nullable().optional()
+});
+const SyncExportStarted = z.object({
+	message: z.string(),
+	task_id: z.number().int().positive()
+});
+const SyncStashStarted = z.object({
+	status: z.literal("success"),
+	message: z.string(),
+	task_id: z.number().int().positive()
+});
+const RemoteSyncSetting = z.string().nullable();
+const RemoteSyncBranchProperty = SessionProperties.extend({ "remote-sync-branch": z.string().nullable().optional() });
+const RemoteSyncUrlProperty = SessionProperties.extend({ "remote-sync-url": z.string().nullable().optional() });
+const BRANCH_UNREADABLE_MESSAGE = "the remote-sync-branch setting is not readable: only admins see it, and a server without remote sync has none";
+const BRANCH_UNSET_MESSAGE = "git-sync tracks no branch: the remote-sync-branch setting is unset";
+const RemoteSyncStateProperty = RemoteSyncBranchProperty.extend({
+	"remote-sync-enabled": z.boolean().optional(),
+	"remote-sync-type": RemoteSyncState.shape.sync_type.optional()
+});
+const REMOTE_SYNC_STATE_ABSENT_MESSAGE = "the remote-sync-enabled and remote-sync-type settings are absent: the server has no remote-sync module";
+function isRemoteUnreadable(error) {
+	if (!(error instanceof HttpError)) return false;
+	return error.status === 403 || error.status === 404;
+}
+function gitSyncResource(transport) {
+	const { explain, refuse, refuseAfterReading } = explainer(transport, "gitSync");
+	/** Get the running or most recently finished sync task, or null when the server has none. */
+	async function currentTask(options = {}) {
+		return fetchOptionalParsed(transport, "/api/ee/remote-sync/current-task", SyncTask, options);
+	}
+	/** Request cancellation of the running sync task, and answer it in the state that left it. */
+	async function cancelTask(options = {}) {
+		return transport.requestParsed(SyncTask, "/api/ee/remote-sync/current-task/cancel", {
+			...options,
+			method: "POST"
+		});
+	}
+	/** Whether Metabase holds content changes the remote has not been told about. */
+	async function isDirty(options = {}) {
+		return (await transport.requestParsed(SyncDirtyFlag, "/api/ee/remote-sync/is-dirty", { ...options })).is_dirty;
+	}
+	/** List the objects whose local state differs from the remote. */
+	async function dirty(options = {}) {
+		return {
+			data: (await transport.requestParsed(SyncDirtyList, "/api/ee/remote-sync/dirty", { ...options })).dirty,
+			total: null
+		};
+	}
+	/**
+	* Compare the tracked remote branch against what Metabase last imported. The server caches the
+	* comparison; `force-refresh` re-reads the remote instead.
+	*/
+	async function hasRemoteChanges(params = {}, options = {}) {
+		return transport.requestParsed(SyncRemoteChanges, "/api/ee/remote-sync/has-remote-changes", {
+			...options,
+			query: { "force-refresh": params["force-refresh"] }
+		});
+	}
+	/**
+	* Import content from the remote into Metabase. The endpoint queues a task and returns at once;
+	* pass `wait` to poll that task until it reaches a terminal status. A server already up to date
+	* answers no task id, and there is then nothing to poll. A server that guards the tracked branch
+	* refuses with 409 when `expected_branch` disagrees with the setting; left out, it is the tracked
+	* branch as read just before the request, on every server with remote sync. A server that guards
+	* the branch also requires it, so there the request is refused before the wire when the setting
+	* is unset or hidden from the caller; a server without the guard ignores the assertion, and gets
+	* none when there is none to read. `merge` folds the remote's changes into local content by a
+	* three-way merge and keeps un-pushed local changes, where a plain import refuses on a dirty
+	* instance.
+	*/
+	async function importFromRemote(params = {}, options = {}) {
+		const expectedBranch = await expectedBranchFor(params.expected_branch, options);
+		await requireMerge(params.merge, options);
+		const started = await transport.requestParsed(SyncImportStarted, "/api/ee/remote-sync/import", {
+			...options,
+			method: "POST",
+			body: {
+				branch: params.branch,
+				force: params.force,
+				merge: params.merge,
+				expected_branch: expectedBranch
+			}
+		});
+		const message = started.message ?? null;
+		if (params.wait === void 0 || started.task_id === null) return {
+			message,
+			task_id: started.task_id
+		};
+		return {
+			message,
+			task_id: started.task_id,
+			final: await settle(params.wait, options)
+		};
+	}
+	async function expectedBranchFor(given, options) {
+		if (given !== void 0) return given;
+		return importAssertion(await readTrackedBranch(options));
+	}
+	async function exportBranchFor(given, options) {
+		if (given !== void 0) return given;
+		return exportBranch(await readTrackedBranch(options));
+	}
+	async function readTrackedBranch(options) {
+		const properties = await transport.probe(RemoteSyncBranchProperty, options);
+		return {
+			tracked: properties["remote-sync-branch"],
+			features: profileFromProperties(properties).features
+		};
+	}
+	async function requireMerge(merge, options) {
+		if (merge === true) await transport.requireFeatures(["remoteSyncMerge"], options);
+	}
+	/**
+	* Export Metabase's content to the remote. The endpoint queues a task and returns at once; pass
+	* `wait` to poll that task until it reaches a terminal status. A server that guards the tracked
+	* branch refuses with 409 when `branch` is not the tracked one; left out, it is the tracked
+	* branch as read just before the request, and the request is refused before the wire when the
+	* setting is unset or hidden from the caller. A server without the guard exports to a named
+	* `branch` and tracks it from then on; left out, it gets none and exports to its own. When the
+	* remote has moved past the last sync, a plain export ends in a `conflict` task where `merge` is
+	* available, and is refused with 400 before any task elsewhere; `merge` folds the remote's
+	* changes in by a three-way merge instead, and `force` overwrites them.
+	*/
+	async function exportToRemote(params = {}, options = {}) {
+		const branchName = await exportBranchFor(params.branch, options);
+		await requireMerge(params.merge, options);
+		const started = await transport.requestParsed(SyncExportStarted, "/api/ee/remote-sync/export", {
+			...options,
+			method: "POST",
+			body: {
+				branch: branchName,
+				message: params.message,
+				force: params.force,
+				merge: params.merge
+			}
+		});
+		const accepted = {
+			message: started.message,
+			task_id: started.task_id,
+			branch: branchName ?? null
+		};
+		if (params.wait === void 0) return accepted;
+		return {
+			...accepted,
+			final: await settle(params.wait, options)
+		};
+	}
+	/**
+	* Preview what exporting to `branch` would do against the live remote, without writing: whether
+	* the remote has moved on, whether a merge would apply cleanly, which entities conflict, and what
+	* a force push would discard. `branch` must be the one git-sync tracks; the server answers 409
+	* otherwise.
+	*/
+	async function exportPreflight(params, options = {}) {
+		return transport.requestParsed(SyncExportPreflight, "/api/ee/remote-sync/export-preflight", {
+			...options,
+			query: { branch: params.branch }
+		});
+	}
+	/**
+	* Export Metabase's current content to a branch the remote does not have yet. The endpoint
+	* queues a task and returns at once; pass `wait` to poll that task to a terminal status.
+	*/
+	async function stash(params, options = {}) {
+		const started = await transport.requestParsed(SyncStashStarted, "/api/ee/remote-sync/stash", {
+			...options,
+			method: "POST",
+			body: {
+				new_branch: params.new_branch,
+				message: params.message
+			}
+		});
+		if (params.wait === void 0) return {
+			status: started.status,
+			message: started.message,
+			task_id: started.task_id
+		};
+		return {
+			status: started.status,
+			message: started.message,
+			task_id: started.task_id,
+			final: await settle(params.wait, options)
+		};
+	}
+	/** List the branches the configured remote carries. */
+	async function branches(options = {}) {
+		return {
+			data: (await transport.requestParsed(SyncBranchList, "/api/ee/remote-sync/branches", { ...options })).items,
+			total: null
+		};
+	}
+	/** Create a branch on the remote and point git-sync at it. */
+	async function createBranch(params, options = {}) {
+		return transport.requestParsed(SyncBranchCreated, "/api/ee/remote-sync/create-branch", {
+			...options,
+			method: "POST",
+			body: { name: params.name }
+		});
+	}
+	/**
+	* Mark one collection as git-synced, or unmark it. The server cascades the flag to descendants
+	* by location prefix, and may queue an import task to bring the instance in line with the
+	* remote. A server without `remoteSyncCollectionsOnlyUpdate` validates every settings update as
+	* a remote configuration and fails one naming no remote, after it has applied the flag, so it is
+	* sent the remote's URL and its token as the server shows it, which it checks against the remote
+	* and keeps as they are, or a blank URL when no remote is configured, which clears the remote
+	* settings that are already empty.
+	*/
+	async function setCollectionSynced(collectionId, synced, options = {}) {
+		return transport.requestParsed(SyncSettingsUpdateResult, "/api/ee/remote-sync/settings", {
+			...options,
+			method: "PUT",
+			body: await settingsUpdateBody({ [collectionId]: synced }, options)
+		});
+	}
+	async function settingsUpdateBody(collections, options) {
+		const { features } = await transport.server(options);
+		if (features.remoteSyncCollectionsOnlyUpdate) return { collections };
+		const url = (await transport.probe(RemoteSyncUrlProperty, options))["remote-sync-url"];
+		if (url === void 0) return { collections };
+		if (url === null) return {
+			collections,
+			"remote-sync-url": ""
+		};
+		const token = await fetchOptionalParsed(transport, "/api/setting/remote-sync-token", RemoteSyncSetting, options);
+		if (token === null) return {
+			collections,
+			"remote-sync-url": url
+		};
+		return {
+			collections,
+			"remote-sync-url": url,
+			"remote-sync-token": token
+		};
+	}
+	/** The collections currently in git-sync's scope. */
+	async function syncedCollections(options = {}) {
+		return {
+			data: (await listCollectionsAs(transport, SyncScopeCollection, options)).filter((entry) => entry.is_remote_synced === true),
+			total: null
+		};
+	}
+	/** The remote's URL, or null when none is configured or the caller may not read it. */
+	async function remoteUrl(options = {}) {
+		try {
+			const url = await fetchOptionalParsed(transport, "/api/setting/remote-sync-url", RemoteSyncSetting, options);
+			return url === "" ? null : url;
+		} catch (error) {
+			if (isRemoteUnreadable(error)) return null;
+			throw error;
+		}
+	}
+	/**
+	* The branch git-sync tracks, or null when none is configured. Refuses when the server has no
+	* remote sync or the caller may not read the setting (it is admin-only), rather than reading
+	* either as unset.
+	*/
+	function branch(properties) {
+		const tracked = properties["remote-sync-branch"];
+		if (tracked === void 0) throw new ConfigError(BRANCH_UNREADABLE_MESSAGE);
+		return tracked;
+	}
+	/**
+	* Whether a remote is configured, through the settings or the environment, the direction the
+	* instance syncs in, which is `read-only` until an admin sets it, and the branch it tracks, all
+	* from one read. The remote's URL is visible to admins only and absent when the environment sets
+	* it, so `configured` is read from its own setting. Refused like `branch` when the caller may not
+	* read the branch, and on a server without the remote-sync module.
+	*/
+	function remote(properties) {
+		const tracked = branch(properties);
+		const configured = properties["remote-sync-enabled"];
+		const syncType = properties["remote-sync-type"];
+		if (configured === void 0 || syncType === void 0) throw new ConfigError(REMOTE_SYNC_STATE_ABSENT_MESSAGE);
+		return {
+			configured,
+			sync_type: syncType,
+			branch: tracked
+		};
+	}
+	/**
+	* The branch git-sync tracks, refused when none is configured, the server has no remote sync, or
+	* the caller may not read it.
+	*/
+	function trackedBranch(properties) {
+		const tracked = branch(properties);
+		if (tracked === null) throw new ConfigError(BRANCH_UNSET_MESSAGE);
+		return tracked;
+	}
+	/**
+	* Poll the current task until it reaches a terminal status. A server with no task at all
+	* answers null, which is terminal in the same sense: nothing further will happen.
+	*/
+	async function waitForTask(wait, options = {}) {
+		return settle(wait, options);
+	}
+	async function settle(wait, options) {
+		return pollUntil(async (signal) => currentTask({
+			...options,
+			signal
+		}), (task) => task === null || isSyncTaskTerminal(task.status), wait);
+	}
+	return {
+		currentTask: explain("currentTask", currentTask),
+		cancelTask: explain("cancelTask", cancelTask),
+		isDirty: explain("isDirty", isDirty),
+		dirty: explain("dirty", dirty),
+		hasRemoteChanges: explain("hasRemoteChanges", hasRemoteChanges),
+		import: explain("import", importFromRemote),
+		export: explain("export", exportToRemote),
+		exportPreflight: explain("exportPreflight", exportPreflight),
+		stash: explain("stash", stash),
+		branches: explain("branches", branches),
+		createBranch: explain("createBranch", createBranch),
+		setCollectionSynced: explain("setCollectionSynced", setCollectionSynced),
+		syncedCollections: refuse("syncedCollections", syncedCollections),
+		remoteUrl,
+		branch: refuseAfterReading("branch", RemoteSyncBranchProperty, branch),
+		remote: refuseAfterReading("remote", RemoteSyncStateProperty, remote),
+		trackedBranch: refuseAfterReading("trackedBranch", RemoteSyncBranchProperty, trackedBranch),
+		waitForTask: explain("waitForTask", waitForTask)
+	};
+}
+function importAssertion(read) {
+	if (!read.features.remoteSync) return;
+	if (read.features.remoteSyncBranchGuard) return requiredBranch(read.tracked);
+	return typeof read.tracked === "string" ? read.tracked : void 0;
+}
+function exportBranch(read) {
+	if (!read.features.remoteSync || !read.features.remoteSyncBranchGuard) return;
+	return requiredBranch(read.tracked);
+}
+function requiredBranch(tracked) {
+	if (typeof tracked === "string") return tracked;
+	throw new ConfigError(tracked === null ? BRANCH_UNSET_MESSAGE : BRANCH_UNREADABLE_MESSAGE);
+}
+//#endregion
+export { SyncScopeCollection, gitSyncResource };

package/dist/resources/glossary.d.ts

@@ -0,0 +1,2 @@
+import { n as glossaryResource, t as GlossaryListParams } from "../glossary-CqFlzW33.js";
+export { GlossaryListParams, glossaryResource };

package/dist/resources/glossary.js

@@ -0,0 +1,51 @@
+import { Glossary } from "../domain/glossary.js";
+import { z } from "zod";
+//#region src/resources/glossary.ts
+const GlossaryApiList = z.object({ data: z.array(Glossary) }).loose();
+function glossaryResource(transport) {
+	/**
+	* List glossary entries in term order. `search` keeps the entries whose term or definition
+	* contains it, case-insensitively.
+	*/
+	async function list(params = {}, options = {}) {
+		return {
+			data: (await transport.requestParsed(GlossaryApiList, "/api/glossary", {
+				...options,
+				query: { search: params.search }
+			})).data,
+			total: null
+		};
+	}
+	/** Create a glossary entry, a term and its definition. Terms are unique. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Glossary, "/api/glossary", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Replace the term and definition of a glossary entry by id. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Glossary, `/api/glossary/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a glossary entry by id. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/glossary/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list,
+		create,
+		update,
+		delete: remove
+	};
+}
+//#endregion
+export { glossaryResource };

package/dist/resources/library.d.ts

@@ -0,0 +1,85 @@
+import { f as RequestOptions, h as Transport } from "../transport-E0ZaPNWJ.js";
+//#region src/resources/library.d.ts
+declare function libraryResource(transport: Transport): {
+  get: (options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: string | number;
+    name: string;
+    effective_children: {
+      id: string | number;
+      name: string;
+      description: string | null;
+      type: "library" | "instance-analytics" | "trash" | "library-data" | "library-metrics" | "library-dashboards" | "tenant-specific-root-collection" | null;
+      is_remote_synced: boolean | null;
+    }[];
+    description?: string | null | undefined;
+    archived?: boolean | undefined;
+    location?: string | null | undefined;
+    parent_id?: string | number | null | undefined;
+    personal_owner_id?: number | null | undefined;
+    is_personal?: boolean | undefined;
+    authority_level?: "official" | null | undefined;
+    type?: "library" | "instance-analytics" | "trash" | "library-data" | "library-metrics" | "library-dashboards" | "tenant-specific-root-collection" | null | undefined;
+    namespace?: "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "data-apps" | "data-actions" | null | undefined;
+    entity_id?: string | null | undefined;
+    slug?: string | undefined;
+    can_write?: boolean | undefined;
+    is_remote_synced?: boolean | null | undefined;
+  } | null>;
+  create: (options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: string | number;
+    name: string;
+    effective_children: {
+      id: string | number;
+      name: string;
+      description: string | null;
+      type: "library" | "instance-analytics" | "trash" | "library-data" | "library-metrics" | "library-dashboards" | "tenant-specific-root-collection" | null;
+      is_remote_synced: boolean | null;
+    }[];
+    description?: string | null | undefined;
+    archived?: boolean | undefined;
+    location?: string | null | undefined;
+    parent_id?: string | number | null | undefined;
+    personal_owner_id?: number | null | undefined;
+    is_personal?: boolean | undefined;
+    authority_level?: "official" | null | undefined;
+    type?: "library" | "instance-analytics" | "trash" | "library-data" | "library-metrics" | "library-dashboards" | "tenant-specific-root-collection" | null | undefined;
+    namespace?: "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "data-apps" | "data-actions" | null | undefined;
+    entity_id?: string | null | undefined;
+    slug?: string | undefined;
+    can_write?: boolean | undefined;
+    is_remote_synced?: boolean | null | undefined;
+  }>;
+  ensureDataCollectionId: (options?: RequestOptions | undefined) => Promise<number>;
+  publishTables: (params: {
+    collection_id: number;
+    database_ids?: number[] | undefined;
+    schema_ids?: string[] | undefined;
+    table_ids?: number[] | undefined;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: string | number;
+    name: string;
+    description?: string | null | undefined;
+    archived?: boolean | undefined;
+    location?: string | null | undefined;
+    parent_id?: string | number | null | undefined;
+    personal_owner_id?: number | null | undefined;
+    is_personal?: boolean | undefined;
+    authority_level?: "official" | null | undefined;
+    type?: "library" | "instance-analytics" | "trash" | "library-data" | "library-metrics" | "library-dashboards" | "tenant-specific-root-collection" | null | undefined;
+    namespace?: "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "data-apps" | "data-actions" | null | undefined;
+    entity_id?: string | null | undefined;
+    slug?: string | undefined;
+    can_write?: boolean | undefined;
+    is_remote_synced?: boolean | null | undefined;
+  } | null>;
+  unpublishTables: (params: {
+    database_ids?: number[] | undefined;
+    schema_ids?: string[] | undefined;
+    table_ids?: number[] | undefined;
+  }, options?: RequestOptions | undefined) => Promise<void>;
+};
+//#endregion
+export { libraryResource };

package/dist/resources/library.js

@@ -0,0 +1,90 @@
+import { TableSelectors } from "../domain/table.js";
+import { Collection } from "../domain/collection.js";
+import { listCollectionsAs } from "./collection.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { LibraryCollectionInfo, LibraryPublishTablesInput, libraryWireSchema, toLibrary } from "../domain/library.js";
+import { parseRequestBody } from "./request-body.js";
+import { z } from "zod";
+//#region src/resources/library.ts
+const LIBRARY_ROOT_PATH = "/api/ee/library/";
+const PUBLISH_TABLES_PATH = "/api/ee/data-studio/table/publish-tables";
+const UNPUBLISH_TABLES_PATH = "/api/ee/data-studio/table/unpublish-tables";
+const LIBRARY_DATA_TYPE = "library-data";
+const PublishTablesResponse = z.object({ target_collection: Collection.nullable() });
+function libraryResource(transport) {
+	const { explain } = explainer(transport, "library");
+	/** Get the Library root and its child collections, or `null` on an instance that has none. */
+	async function get(options = {}) {
+		const { features } = await transport.server(options);
+		const wire = await transport.requestParsed(libraryWireSchema(features), LIBRARY_ROOT_PATH, { ...options });
+		if (wire === null) return null;
+		return toLibrary(wire, await libraryListing(options));
+	}
+	async function libraryListing(options) {
+		const data = await listCollectionsAs(transport, LibraryCollectionInfo, options);
+		const byId = /* @__PURE__ */ new Map();
+		for (const collection of data) if (typeof collection.id === "number") byId.set(collection.id, collection);
+		return byId;
+	}
+	/**
+	* Create the Library subtree (its Data and Metrics collections). Metabase takes no body, rejects
+	* a second create with a 400, and answers the bare root collection without its
+	* `effective_children` — so an existing Library short-circuits the call and a fresh one comes
+	* back from a refetch, which together make this idempotent.
+	*/
+	async function create(options = {}) {
+		const existing = await get(options);
+		if (existing !== null) return existing;
+		await transport.requestRaw(LIBRARY_ROOT_PATH, {
+			...options,
+			method: "POST"
+		});
+		const created = await get(options);
+		if (created === null) throw new Error(`Library was not created after POST ${LIBRARY_ROOT_PATH}`);
+		return created;
+	}
+	/** The id of the Library's Data collection, creating the Library first when it does not exist. */
+	async function ensureDataCollectionId(options = {}) {
+		const data = (await create(options)).effective_children.find((child) => child.type === LIBRARY_DATA_TYPE);
+		if (data === void 0) throw new Error("Library has no Data collection to publish into");
+		if (typeof data.id !== "number") throw new Error(`Library Data collection has a non-numeric id ${String(data.id)}`);
+		return data.id;
+	}
+	/**
+	* Publish tables — and every upstream table they depend on — into a collection, so they lead the
+	* data pickers and rank up in search. Answers the collection they landed in. The endpoint
+	* answers the same whether or not the selectors matched a table, so a body that does not match
+	* `LibraryPublishTablesInput` is refused before any request.
+	*/
+	async function publishTables(params, options = {}) {
+		const body = parseRequestBody(LibraryPublishTablesInput, params, "tables to publish");
+		return (await transport.requestParsed(PublishTablesResponse, PUBLISH_TABLES_PATH, {
+			...options,
+			method: "POST",
+			body
+		})).target_collection;
+	}
+	/**
+	* Clear the Library collection from tables, and recursively from every downstream table that
+	* depends on them. The endpoint answers no JSON body, whether or not the selectors matched a
+	* table, so selectors that do not match `TableSelectors` are refused before any request.
+	*/
+	async function unpublishTables(params, options = {}) {
+		const body = parseRequestBody(TableSelectors, params, "table selectors");
+		await transport.requestRaw(UNPUBLISH_TABLES_PATH, {
+			...options,
+			method: "POST",
+			body,
+			expectContentType: "binary"
+		});
+	}
+	return {
+		get: explain("get", get),
+		create: explain("create", create),
+		ensureDataCollectionId: explain("ensureDataCollectionId", ensureDataCollectionId),
+		publishTables: explain("publishTables", publishTables),
+		unpublishTables: explain("unpublishTables", unpublishTables)
+	};
+}
+//#endregion
+export { libraryResource };

package/dist/resources/measure.d.ts

@@ -0,0 +1,2 @@
+import { n as measureResource, t as MeasureArchiveParams } from "../measure-CuMqPbQX.js";
+export { MeasureArchiveParams, measureResource };

package/dist/resources/measure.js

@@ -0,0 +1,57 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { Measure } from "../domain/measure.js";
+import { z } from "zod";
+//#region src/resources/measure.ts
+const MeasureApiList = z.array(Measure);
+function measureResource(transport) {
+	const { explain } = explainer(transport, "measure");
+	/** List measures. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(MeasureApiList, "/api/measure", { ...options }),
+			total: null
+		};
+	}
+	/** Get one measure by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Measure, `/api/measure/${id}`, { ...options });
+	}
+	/** Create a measure — a saved aggregation tied to a table — from a full measure body. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Measure, "/api/measure", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a measure by id, patching only the fields the body carries. `revision_message` is
+	* required and lands in the audit log.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Measure, `/api/measure/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a measure by id. Metabase models this as an update, not its own endpoint,
+	* so it carries the same required `revision_message`.
+	*/
+	async function archive(id, params, options = {}) {
+		return update(id, {
+			archived: true,
+			revision_message: params.revision_message
+		}, options);
+	}
+	return {
+		list: explain("list", list),
+		get: explain("get", get),
+		create: explain("create", create),
+		update: explain("update", update),
+		archive: explain("archive", archive)
+	};
+}
+//#endregion
+export { measureResource };

package/dist/resources/metric.d.ts

@@ -0,0 +1,2 @@
+import { i as metricResource, r as MetricDimensionListParams } from "../client-DNRvXFRm.js";
+export { MetricDimensionListParams, metricResource };