@metabase/client 0.0.0-stage → 0.1.1

package/dist/resources/revision.d.ts

@@ -0,0 +1,70 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+//#region src/resources/revision.d.ts
+declare function revisionResource(transport: Transport): {
+  list: (entity: "transform" | "card" | "dashboard" | "document" | "measure" | "segment" | "transform-test", id: number, options?: RequestOptions | undefined) => Promise<ListResult<{
+    [x: string]: unknown;
+    id: number;
+    timestamp: string;
+    is_creation: boolean;
+    is_reversion: boolean;
+    most_recent: boolean;
+    diff: {
+      [x: string]: unknown;
+    } | null;
+    description: string;
+    has_multiple_changes: boolean;
+    user: {
+      [x: string]: unknown;
+      id: number;
+      first_name: string | null;
+      last_name: string | null;
+      common_name: string;
+    };
+  }>>;
+  revert: (params: {
+    entity: "transform" | "card" | "dashboard" | "document" | "measure" | "segment" | "transform-test";
+    id: number;
+    revision_id: number;
+  }, options?: RequestOptions | undefined) => Promise<{
+    outcome: "reverted";
+    revision: {
+      [x: string]: unknown;
+      id: number;
+      timestamp: string;
+      is_creation: boolean;
+      is_reversion: boolean;
+      most_recent: boolean;
+      diff: {
+        [x: string]: unknown;
+      } | null;
+      description: string;
+      has_multiple_changes: boolean;
+      user: {
+        [x: string]: unknown;
+        id: number;
+        first_name: string | null;
+        last_name: string | null;
+        common_name: string;
+      };
+    };
+  } | {
+    outcome: "unchanged";
+    revision: {
+      [x: string]: unknown;
+      id: number;
+      model: string;
+      model_id: number;
+      user_id: number;
+      object: {
+        [x: string]: unknown;
+      };
+      timestamp: string;
+      is_creation: boolean;
+      is_reversion: boolean;
+      most_recent: boolean;
+    };
+  }>;
+};
+//#endregion
+export { revisionResource };

package/dist/resources/revision.js

@@ -0,0 +1,46 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { gateTriggered } from "../version/input-gates.js";
+import { REVISION_ENTITY_GATES, Revision, RevisionRow } from "../domain/revision.js";
+import { z } from "zod";
+//#region src/resources/revision.ts
+const RevisionApiList = z.array(Revision);
+const RevisionApiRevert = z.union([Revision.transform((revision) => ({
+	outcome: "reverted",
+	revision
+})), RevisionRow.transform((revision) => ({
+	outcome: "unchanged",
+	revision
+}))]);
+function entityFeatures(entity) {
+	return REVISION_ENTITY_GATES.filter((gate) => gateTriggered(gate, entity)).map((gate) => ({
+		feature: gate.feature,
+		fields: ["entity"]
+	}));
+}
+function revisionResource(transport) {
+	const { explain } = explainer(transport, "revision");
+	/** List the revisions of an entity the caller may read, newest first, each with its diff. */
+	async function list(entity, id, options = {}) {
+		return {
+			data: await transport.requestParsed(RevisionApiList, `/api/revision/${entity}/${id}`, { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Revert an entity to one of its prior revisions. Needs write access to the entity, and for a
+	* card the permission to run the query being restored.
+	*/
+	async function revert(params, options = {}) {
+		return transport.requestParsed(RevisionApiRevert, "/api/revision/revert", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return {
+		list: explain("list", list, entityFeatures),
+		revert: explain("revert", revert, (params) => entityFeatures(params.entity))
+	};
+}
+//#endregion
+export { revisionResource };

package/dist/resources/search.d.ts

@@ -0,0 +1,2 @@
+import { n as SearchParams, r as searchResource, t as SearchPage } from "../search-Cten2h0I.js";
+export { SearchPage, SearchParams, searchResource };

package/dist/resources/search.js

@@ -0,0 +1,78 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { SearchResult } from "../domain/search.js";
+import { z } from "zod";
+//#region src/resources/search.ts
+const SearchApiResponse = z.object({
+	data: z.array(SearchResult),
+	total: z.number().int().nonnegative()
+}).loose();
+function verifiedFeatures(params = {}) {
+	return params.verified === true ? [{
+		feature: "contentVerification",
+		fields: ["verified"]
+	}] : [];
+}
+const MODELS_FIELDS = ["models"];
+const SEARCH_MODEL_FEATURES = {
+	measure: "measures",
+	transform: "transforms",
+	exploration: "explorations"
+};
+function modelFeatures(params) {
+	if (params.models === void 0) return [];
+	return params.models.flatMap((model) => {
+		const feature = SEARCH_MODEL_FEATURES[model];
+		return feature === void 0 ? [] : [{
+			feature,
+			fields: MODELS_FIELDS
+		}];
+	});
+}
+function queryFeatures(params = {}) {
+	return [...verifiedFeatures(params), ...modelFeatures(params)];
+}
+function searchResource(transport) {
+	const { explain } = explainer(transport, "search");
+	/**
+	* Search over the instance's content, ranked against `q`. `models` narrows which kinds of entity
+	* may match, `archived` swaps the active set for the archived one, `table_db_id` restricts to
+	* items on one database, `verified` to verified content, `collection` to one collection and its
+	* descendants, `created_by` to items created by any of those users, `search_native_query` also
+	* matches native query text but narrows to the models that carry one (cards, models, metrics,
+	* actions, transforms), `include_metadata` attaches each card's `result_metadata`,
+	* `include_dashboard_questions` also matches questions saved into a dashboard (excluded by
+	* default), and `limit`/`offset` are the window the server applies before ranking hydration.
+	* `verified` needs the `content_verification` premium feature, and is refused before the wire
+	* without it: a server granting neither it nor `official_collections` refuses the filter, and one
+	* granting `official_collections` alone takes it without applying it. `models` takes `measure`
+	* only with `measures`, `transform` with `transforms` or on a Metabase 58 enterprise build, and
+	* `exploration` only with `explorations`.
+	*/
+	async function query(params = {}, options = {}) {
+		await transport.requireFeatures(verifiedFeatures(params).map((requirement) => requirement.feature), options);
+		const response = await transport.requestParsed(SearchApiResponse, "/api/search", {
+			...options,
+			query: {
+				q: params.q,
+				models: params.models,
+				archived: params.archived,
+				limit: params.limit,
+				offset: params.offset,
+				table_db_id: params.table_db_id,
+				verified: params.verified,
+				collection: params.collection,
+				created_by: params.created_by,
+				search_native_query: params.search_native_query,
+				include_metadata: params.include_metadata,
+				include_dashboard_questions: params.include_dashboard_questions
+			}
+		});
+		return {
+			data: response.data,
+			total: response.total
+		};
+	}
+	return { query: explain("query", query, queryFeatures) };
+}
+//#endregion
+export { searchResource };

package/dist/resources/segment.d.ts

@@ -0,0 +1,2 @@
+import { n as segmentResource, t as SegmentArchiveParams } from "../segment-DQLX6r1E.js";
+export { SegmentArchiveParams, segmentResource };

package/dist/resources/segment.js

@@ -0,0 +1,55 @@
+import { Segment } from "../domain/segment.js";
+import { z } from "zod";
+//#region src/resources/segment.ts
+const SegmentApiList = z.array(Segment);
+function segmentResource(transport) {
+	/** List every segment the caller can see. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(SegmentApiList, "/api/segment", { ...options }),
+			total: null
+		};
+	}
+	/** Get one segment by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Segment, `/api/segment/${id}`, { ...options });
+	}
+	/** Create a segment — a reusable row filter over one table — from a full segment body. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Segment, "/api/segment", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a segment by id, patching only the fields the body carries. `revision_message` is
+	* required: Metabase records every segment change in its revision history.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Segment, `/api/segment/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a segment by id. Metabase models this as an update, 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,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+export { segmentResource };

package/dist/resources/setting.d.ts

@@ -0,0 +1,11 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+import { t as Setting } from "../setting-DXuQGXGF.js";
+//#region src/resources/setting.d.ts
+declare function settingResource(transport: Transport): {
+  list: (options?: RequestOptions) => Promise<ListResult<Setting>>;
+  get: (key: string, options?: RequestOptions) => Promise<unknown>;
+  set: (key: string, value: unknown, options?: RequestOptions) => Promise<void>;
+};
+//#endregion
+export { settingResource };

package/dist/resources/setting.js

@@ -0,0 +1,43 @@
+import { ConfigError, errorMessage } from "../errors.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { Setting } from "../domain/setting.js";
+import { z } from "zod";
+//#region src/resources/setting.ts
+const SettingApiList = z.array(Setting);
+const UNKNOWN_SETTING_PREFIX = "Unknown setting:";
+function rethrowSettingError(error, key) {
+	if (errorMessage(error).startsWith(UNKNOWN_SETTING_PREFIX)) throw new ConfigError(`unknown setting: ${key}`);
+	throw error;
+}
+function settingResource(transport) {
+	/** Get all settings and their values, with descriptions and environment-variable names. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(SettingApiList, "/api/setting", { ...options }),
+			total: null
+		};
+	}
+	/**
+	* Fetch a single setting's value by key. An unset setting answers 204 rather than 404, which
+	* reaches the caller as `null`; a string-typed setting answers bare text rather than JSON.
+	*/
+	async function get(key, options = {}) {
+		return fetchOptionalParsed(transport, `/api/setting/${encodeURIComponent(key)}`, z.unknown(), options).catch((error) => rethrowSettingError(error, key));
+	}
+	/** Set a single setting's value by key. The endpoint answers 204 with no body. */
+	async function set(key, value, options = {}) {
+		await transport.requestRaw(`/api/setting/${encodeURIComponent(key)}`, {
+			...options,
+			method: "PUT",
+			body: { value },
+			expectContentType: "binary"
+		}).catch((error) => rethrowSettingError(error, key));
+	}
+	return {
+		list,
+		get,
+		set
+	};
+}
+//#endregion
+export { settingResource };

package/dist/resources/setup.d.ts

@@ -0,0 +1,8 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { n as SetupResult, t as SetupInput } from "../setup-JqcJ2unJ.js";
+//#region src/resources/setup.d.ts
+declare function setupResource(transport: Transport): {
+  create: (params: SetupInput, options?: RequestOptions) => Promise<SetupResult>;
+};
+//#endregion
+export { setupResource };

package/dist/resources/setup.js

@@ -0,0 +1,18 @@
+import { SetupResult } from "../domain/setup.js";
+//#region src/resources/setup.ts
+function setupResource(transport) {
+	/**
+	* Complete the initial setup wizard on a fresh instance, creating its first admin user and
+	* applying the instance preferences. The setup token is single-use.
+	*/
+	async function create(params, options = {}) {
+		return transport.requestParsed(SetupResult, "/api/setup", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	return { create };
+}
+//#endregion
+export { setupResource };

package/dist/resources/snippet.d.ts

@@ -0,0 +1,2 @@
+import { n as snippetResource, t as SnippetListParams } from "../snippet-Djn0rL21.js";
+export { SnippetListParams, snippetResource };

package/dist/resources/snippet.js

@@ -0,0 +1,52 @@
+import { Snippet } from "../domain/snippet.js";
+import { z } from "zod";
+//#region src/resources/snippet.ts
+const SnippetApiList = z.array(Snippet);
+function snippetResource(transport) {
+	/** List native query snippets. `archived` swaps the listing to archived snippets. */
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(SnippetApiList, "/api/native-query-snippet", {
+				...options,
+				query: { archived: params.archived }
+			}),
+			total: null
+		};
+	}
+	/** Get one native query snippet by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, { ...options });
+	}
+	/** Create a native query snippet from a name, its SQL fragment, and an optional collection. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(Snippet, "/api/native-query-snippet", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Update a native query snippet by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(Snippet, `/api/native-query-snippet/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Archive (soft-delete) a native query snippet by id. Metabase models this as an update, not its
+	* own endpoint.
+	*/
+	async function archive(id, options = {}) {
+		return update(id, { archived: true }, options);
+	}
+	return {
+		list,
+		get,
+		create,
+		update,
+		archive
+	};
+}
+//#endregion
+export { snippetResource };

package/dist/resources/table.d.ts

@@ -0,0 +1,2 @@
+import { n as tableResource, t as TableListParams } from "../table-CDZbLNow.js";
+export { TableListParams, tableResource };

package/dist/resources/table.js

@@ -0,0 +1,274 @@
+import { PartialWriteError } from "../errors.js";
+import { CapabilityError } from "../version/capability-error.js";
+import { supersedingFeature } from "../version/requirement-check.js";
+import { DATA_AUTHORITY_WITHDRAWAL_GATE, DATA_LAYER_MEDALLION_GATE, DATA_LAYER_TIER_GATE, Table, TableDataLayerTier, TableForeignKey, TableQueryMetadata, TableSelectors } from "../domain/table.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { buildCsvFormData } from "./csv-upload.js";
+import { parseRequestBody } from "./request-body.js";
+import { gateTriggered } from "../version/input-gates.js";
+import { fetchOptionalParsed } from "./optional-parsed.js";
+import { z } from "zod";
+//#region src/resources/table.ts
+const TableApiList = z.array(Table);
+const TableApiFks = z.array(TableForeignKey);
+const SyncSchemaResponse = z.object({ status: z.literal("ok") });
+const FieldValuesResponse = z.object({ status: z.literal("success") });
+const BulkEditResponse = z.object({});
+const BULK_EDIT_PATH = "/api/data-studio/table/edit";
+const BULK_SYNC_SCHEMA_PATH = "/api/data-studio/table/sync-schema";
+const BULK_RESCAN_VALUES_PATH = "/api/data-studio/table/rescan-values";
+const BULK_DISCARD_VALUES_PATH = "/api/data-studio/table/discard-values";
+const LIST_PARAM_FEATURES = [
+	["can-query", "tableListAccessFilters"],
+	["can-write", "tableListAccessFilters"],
+	["include-transform-targets", "tableListTransformTargets"],
+	["unused-only", "tableUnusedFilter"],
+	["published-only", "tableListPublishedFilter"]
+];
+function listParamFeatures(params) {
+	return LIST_PARAM_FEATURES.filter(([param]) => params[param] === true).map(([, feature]) => feature);
+}
+function dataLayerFeatures(value, field) {
+	return gateTriggered(DATA_LAYER_TIER_GATE, value) ? [{
+		feature: DATA_LAYER_TIER_GATE.feature,
+		fields: [field]
+	}] : [];
+}
+const UPLOAD_UPDATE_PATHS = {
+	append: "append-csv",
+	replace: "replace-csv"
+};
+function tableResource(transport) {
+	const { explain } = explainer(transport, "table");
+	/**
+	* List every table the caller can see, across all databases. `term` matches names and display
+	* names; `can-query` and `can-write` keep only the tables the caller may query or edit the
+	* metadata of; `include-transform-targets` adds tables a transform writes to; `unused-only` keeps
+	* tables nothing depends on; `published-only` keeps tables published to the library.
+	*/
+	async function list(params = {}, options = {}) {
+		await transport.requireFeatures(listParamFeatures(params), options);
+		return {
+			data: await transport.requestParsed(TableApiList, "/api/table", {
+				...options,
+				query: {
+					term: params.term,
+					"visibility-type": params["visibility-type"],
+					"data-layer": params["data-layer"],
+					"data-source": params["data-source"],
+					"owner-user-id": params["owner-user-id"],
+					"owner-email": params["owner-email"],
+					"orphan-only": params["orphan-only"],
+					"unused-only": params["unused-only"],
+					"published-only": params["published-only"],
+					"can-query": params["can-query"],
+					"can-write": params["can-write"],
+					"include-transform-targets": params["include-transform-targets"]
+				}
+			}),
+			total: null
+		};
+	}
+	/** Get one table by id, without its fields. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(Table, `/api/table/${id}`, { ...options });
+	}
+	/** Update a table by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		await refuseRewrittenDataLayer(params.data_layer, options);
+		await requireDataAuthorityNull(params.data_authority, options);
+		const path = `/api/table/${id}`;
+		const updated = await transport.requestParsed(Table, path, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+		assertCollectionWritten(path, params.collection_id, updated);
+		return updated;
+	}
+	async function refuseRewrittenDataLayer(value, options) {
+		if (!gateTriggered(DATA_LAYER_MEDALLION_GATE, value)) return;
+		const profile = await transport.preflightServer(options);
+		if (profile === null) return;
+		const detail = `data_layer "${value}" is a medallion name; this server names a table's layer ${TableDataLayerTier.options.join(", ")} and would map it onto one of those without a word`;
+		const failure = supersedingFeature(DATA_LAYER_MEDALLION_GATE.feature, profile, detail);
+		if (failure !== null) transport.refuseBeforeSending(new CapabilityError(failure));
+	}
+	/** Get a table by id with its fields hydrated — the metadata the query builder runs on. */
+	async function queryMetadata(id, options = {}) {
+		return transport.requestParsed(TableQueryMetadata, `/api/table/${id}/query_metadata`, { ...options });
+	}
+	/**
+	* Get every foreign key whose destination is a field of this table. A table with no active
+	* fields answers no content, which is the same empty list.
+	*/
+	async function fks(id, options = {}) {
+		return {
+			data: await fetchOptionalParsed(transport, `/api/table/${id}/fks`, TableApiFks, { ...options }) ?? [],
+			total: null
+		};
+	}
+	/**
+	* Trigger a sync of this table: its columns, their fingerprints and its cached field values. It
+	* never discovers new tables. The sync runs after the call returns; a warehouse the server cannot
+	* connect to is a 422.
+	*/
+	async function syncSchema(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(SyncSchemaResponse, `/api/table/${id}/sync_schema`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Trigger an update of the field values of every eligible field of this table that already has a
+	* cached set. The scan runs after the call returns.
+	*/
+	async function rescanValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(FieldValuesResponse, `/api/table/${id}/rescan_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Discard the cached field values of every field of this table, custom display values included.
+	* No scan recreates a discarded set; the server rebuilds it, without the display values, the next
+	* time the field's values are read.
+	*/
+	async function discardValues(id, options = {}) {
+		return {
+			id,
+			status: (await transport.requestParsed(FieldValuesResponse, `/api/table/${id}/discard_values`, {
+				...options,
+				method: "POST"
+			})).status
+		};
+	}
+	/**
+	* Set the same metadata on every table the selectors pick out. A table leaving the `hidden` data
+	* layer is re-synced after the call returns. The server answers the same whether or not the
+	* selectors matched a table.
+	*/
+	async function bulkEdit(params, options = {}) {
+		await requireDataAuthorityNull(params.data_authority, options);
+		await transport.requestParsed(BulkEditResponse, BULK_EDIT_PATH, {
+			...options,
+			method: "POST",
+			body: params
+		});
+		return {
+			accepted: true,
+			...params
+		};
+	}
+	async function requireDataAuthorityNull(value, options) {
+		if (gateTriggered(DATA_AUTHORITY_WITHDRAWAL_GATE, value)) await transport.requireFeatures([DATA_AUTHORITY_WITHDRAWAL_GATE.feature], options);
+	}
+	async function postSelection(path, selectors, options) {
+		const body = parseRequestBody(TableSelectors, selectors, "table selectors");
+		await transport.requestRaw(path, {
+			...options,
+			method: "POST",
+			body,
+			expectContentType: "binary"
+		});
+		return {
+			accepted: true,
+			...body
+		};
+	}
+	/**
+	* Trigger a sync of every table the selectors pick out: its columns, their fingerprints and its
+	* cached field values. Every database behind them must answer a connection test first, or the
+	* call is a 422; the syncs run after it returns.
+	*/
+	async function bulkSyncSchema(selectors, options = {}) {
+		return postSelection(BULK_SYNC_SCHEMA_PATH, selectors, options);
+	}
+	/**
+	* Trigger a field-values rescan of every table the selectors pick out, refreshing the sets that
+	* are already cached. The scans run after the call returns.
+	*/
+	async function bulkRescanValues(selectors, options = {}) {
+		return postSelection(BULK_RESCAN_VALUES_PATH, selectors, options);
+	}
+	/**
+	* Discard the cached field values of every table the selectors pick out, custom display values
+	* included. No scan recreates a discarded set.
+	*/
+	async function bulkDiscardValues(selectors, options = {}) {
+		return postSelection(BULK_DISCARD_VALUES_PATH, selectors, options);
+	}
+	async function updateFromCsv(id, action, file, options) {
+		await transport.requestRaw(`/api/table/${id}/${UPLOAD_UPDATE_PATHS[action]}`, {
+			...options,
+			method: "POST",
+			body: buildCsvFormData(file),
+			expectContentType: "binary"
+		});
+		return {
+			table_id: id,
+			action
+		};
+	}
+	/**
+	* Inserts the rows of an uploaded CSV file into the table identified by `id`. The table must have
+	* been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function appendCsv(id, file, options = {}) {
+		return updateFromCsv(id, "append", file, options);
+	}
+	/**
+	* Replaces the contents of the table identified by `id` with the rows of an uploaded CSV file.
+	* The table must have been created by uploading a CSV file.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function replaceCsv(id, file, options = {}) {
+		return updateFromCsv(id, "replace", file, options);
+	}
+	return {
+		list: explain("list", list, (params) => dataLayerFeatures(params?.["data-layer"], "data-layer")),
+		get,
+		update: explain("update", update, (_id, params) => dataLayerFeatures(params.data_layer, "data_layer")),
+		queryMetadata,
+		fks,
+		syncSchema,
+		rescanValues,
+		discardValues,
+		bulkEdit: explain("bulkEdit", bulkEdit),
+		bulkSyncSchema: explain("bulkSyncSchema", bulkSyncSchema),
+		bulkRescanValues: explain("bulkRescanValues", bulkRescanValues),
+		bulkDiscardValues: explain("bulkDiscardValues", bulkDiscardValues),
+		appendCsv,
+		replaceCsv
+	};
+}
+function assertCollectionWritten(path, requested, table) {
+	if (requested === void 0 || table.collection_id === requested) return;
+	const answered = table.collection_id === void 0 ? { kind: "unreported" } : {
+		kind: "reported",
+		value: table.collection_id
+	};
+	throw new PartialWriteError(`the server applied the rest of the update to table ${table.id} but not collection_id: ${describeCollectionAnswer(answered)}, because this server does not move a table to a collection through an update`, {
+		method: "PUT",
+		path,
+		field: "collection_id",
+		requested,
+		answered
+	});
+}
+function describeCollectionAnswer(answered) {
+	if (answered.kind === "unreported") return "it answered the table without reporting a collection";
+	if (answered.value === null) return "the table stays in no collection";
+	return `the table stays in collection ${answered.value}`;
+}
+//#endregion
+export { tableResource };