@metabase/client 0.0.0-stage → 0.1.1

package/dist/resources/field.js

@@ -0,0 +1,99 @@
+import { DATA_SENSITIVITY_GATE, FieldSearchMatches, FieldValues, FieldWithDataSensitivity, fieldDetailSchema, fieldRemappedValueSchema } from "../domain/field.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { gateTriggered } from "../version/input-gates.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { z } from "zod";
+//#region src/resources/field.ts
+const FieldApiSummary = z.tuple([z.tuple([z.literal("count"), z.number().int()]), z.tuple([z.literal("distincts"), z.number().int()])]);
+function fieldResource(transport) {
+	const { refuse } = explainer(transport, "field");
+	/**
+	* Get one field by id. A server that labels data sensitivity answers `data_sensitivity`, `null`
+	* for an unlabelled field; any other answers the field without the key (`hasDataSensitivity`).
+	*/
+	async function get(id, options = {}) {
+		const { features } = await transport.server(options);
+		return transport.requestParsed(fieldDetailSchema(features), `/api/field/${id}`, { ...options });
+	}
+	/**
+	* Update a field by id, patching only the fields the body carries. A `data_sensitivity` label is
+	* a person's call the server's classifier never overwrites, and `null` withdraws it so the
+	* classifier's own applies again; a server without the column would drop the key silently, so
+	* the label is refused there before the wire. Answers the field the way `get` does.
+	*/
+	async function update(id, params, options = {}) {
+		await transport.requireFeatures(gateTriggered(DATA_SENSITIVITY_GATE, params.data_sensitivity) ? [DATA_SENSITIVITY_GATE.feature] : [], options);
+		const { features } = await transport.server(options);
+		return transport.requestParsed(fieldDetailSchema(features), `/api/field/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Label a field's data sensitivity by hand. A person's label is never overwritten by the server's
+	* classifier; `null` withdraws it, so whatever label the classifier wrote shows again. A server
+	* without the column drops the key silently, so the label is refused there before the wire.
+	* Answers the field with the label it now carries.
+	*/
+	async function setDataSensitivity(id, params, options = {}) {
+		return transport.requestParsed(FieldWithDataSensitivity, `/api/field/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Search the values of `searchId` that contain `value`, case-insensitively, answering the
+	* matching values of `id` paired with them, ordered by value, at most `limit` of them. An FK on
+	* either side is followed to the PK it points at, and a field that resolves to the same field as
+	* `searchId` answers each value alone. Without `value`, the first `limit` values. A field with
+	* custom display values answers every mapped value with its display value instead, matching
+	* `value` against the display value, ignoring both `searchId` and `limit`.
+	*/
+	async function search(id, searchId, params, options = {}) {
+		return transport.requestParsed(FieldSearchMatches, `/api/field/${id}/search/${searchId}`, {
+			...options,
+			query: {
+				value: params.value,
+				limit: params.limit
+			}
+		});
+	}
+	/**
+	* The value of `remappedId` on the one row where `id` equals `value`, as `[value, remapped]`,
+	* or `null` when no row matches. For a numeric field the server reads the leading number of
+	* `value` and ignores any text after it, refusing only a `value` that has none.
+	*/
+	async function remapping(id, remappedId, params, options = {}) {
+		const { features } = await transport.server(options);
+		return fetchOptionalParsed(transport, `/api/field/${id}/remapping/${remappedId}`, fieldRemappedValueSchema(features, id === remappedId), {
+			...options,
+			query: { value: params.value }
+		});
+	}
+	/** Get the row count and the distinct-value count for a field. */
+	async function summary(id, options = {}) {
+		const [[, count], [, distincts]] = await transport.requestParsed(FieldApiSummary, `/api/field/${id}/summary`, { ...options });
+		return {
+			field_id: id,
+			count,
+			distincts
+		};
+	}
+	/** Get the cached distinct values Metabase holds for a field. */
+	async function values(id, options = {}) {
+		return transport.requestParsed(FieldValues, `/api/field/${id}/values`, { ...options });
+	}
+	return {
+		get,
+		update,
+		setDataSensitivity: refuse("setDataSensitivity", setDataSensitivity),
+		search,
+		remapping,
+		summary,
+		values
+	};
+}
+//#endregion
+export { fieldResource };

package/dist/resources/git-sync.d.ts

@@ -0,0 +1,2 @@
+import { a as SyncRemoteChangesParams, c as SyncWaitParams, i as SyncImportParams, l as gitSyncResource, n as SyncExportParams, o as SyncScopeCollection, r as SyncExportPreflightParams, s as SyncStashParams, t as SyncCreateBranchParams } from "../git-sync-BTf1aYHr.js";
+export { SyncCreateBranchParams, SyncExportParams, SyncExportPreflightParams, SyncImportParams, SyncRemoteChangesParams, SyncScopeCollection, SyncStashParams, SyncWaitParams, gitSyncResource };

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 { t as explainer } from "../refusal-B9aeHMc9.js";
+import { listCollectionsAs } from "./collection.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-DFvnz-E5.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-BsXqRujn.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?: "data-apps" | "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "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?: "data-apps" | "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "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?: "data-apps" | "transforms" | "snippets" | "analytics" | "shared-tenant-collection" | "tenant-specific" | "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 };