@keboola/api-client 27.0.0 → 31.0.0

package/dist/storage-CQxu0EY3.js

@@ -0,0 +1,2432 @@
+import { a as poller, t as jobStatus } from "./jobStatus-DbMupQEK.js";
+import { t as concurrent } from "./concurrent-CH9fbNr3.js";
+import { o as HttpHeader, p as KeboolaHttpHeader, r as isApiError } from "./createFetchClient-B1h3-p65.js";
+import { t as validateConnectionStatus } from "./validateConnectionStatus-CBhXmvWC.js";
+import { t as createGenericFetchClient } from "./createGenericFetchClient-DhpvUSlX.js";
+import { t as createOpenapiFetchClient } from "./createOpenapiFetchClient-0_oqhdPv.js";
+import { t as createAuthHeaders } from "./auth-CE6Hlc9W.js";
+//#region src/utils/async/series.ts
+/**
+* Executes a callback function on an array of items in series (one at a time).
+* It behaves similarly to Promise.all(), failing on the first rejected promise.
+* The order of the results matches the order of the promises.
+* Resolves with the mapped results, not with the original items.
+*/
+const series = async (options) => concurrent({
+	...options,
+	concurrency: 1
+});
+//#endregion
+//#region src/errors/ServiceUnavailableError.ts
+var ServiceUnavailableError = class ServiceUnavailableError extends Error {
+	constructor(serviceId, path, clientName) {
+		super(`Service "${serviceId}" is not available in this stack. Caused by: ${clientName}.${path.join(".")}()`);
+		this.name = "ServiceUnavailableError";
+		Object.setPrototypeOf(this, ServiceUnavailableError.prototype);
+	}
+};
+//#endregion
+//#region src/clients/storage/mergeRequests/mergeRequests.ts
+/**
+* Both write bodies are asserted in: the spec declares every field of them required and nullable,
+* while the API defaults the ones a caller omits — and an explicit `null` is not the same request as
+* an absent key. `./types` narrows each body to what a caller really has to send.
+*/
+const createMergeRequests = (client) => {
+	const getMergeRequests = async (signal) => {
+		const { data } = await client.get("/v2/storage/merge-request", {}, { signal });
+		return data;
+	};
+	const getMergeRequest = async (id, signal) => {
+		const { data } = await client.get("/v2/storage/merge-request/{id}", { path: { id } }, { signal });
+		return data;
+	};
+	const getMergeRequestWithActivityLog = async (id, signal) => {
+		const { data } = await client.get("/v2/storage/merge-request/{id}", {
+			path: { id },
+			query: { include: "activityLog" }
+		}, { signal });
+		return data;
+	};
+	const createMergeRequest = async (body) => {
+		const { data } = await client.post("/v2/storage/merge-request", { body });
+		return data;
+	};
+	const updateMergeRequest = async ({ id, ...body }) => {
+		const { data } = await client.put("/v2/storage/merge-request/{id}", {
+			path: { id },
+			body
+		});
+		return data;
+	};
+	const requestReview = async (id) => {
+		const { data } = await client.put("/v2/storage/merge-request/{id}/request-review", { path: { id } });
+		return data;
+	};
+	const approveMergeRequest = async (id) => {
+		const { data } = await client.put("/v2/storage/merge-request/{id}/approve", { path: { id } });
+		return data;
+	};
+	const requestChangesMergeRequest = async (id, reason) => {
+		const { data } = await client.put("/v2/storage/merge-request/{id}/request-changes", {
+			path: { id },
+			body: reason ? { reason } : void 0
+		});
+		return data;
+	};
+	/**
+	* Merges an approved merge request. The endpoint is async — it returns the created merge job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/merge-requests/PUT/v2/storage/merge-request/{id}/merge
+	*/
+	const mergeMergeRequest = async (id) => {
+		const { data } = await client.put("/v2/storage/merge-request/{id}/merge", { path: { id } });
+		return data;
+	};
+	const getMergeRequestConflicts = async (id, signal) => {
+		const { data } = await client.get("/v2/storage/merge-request/{id}/conflicts", { path: { id } }, { signal });
+		return data;
+	};
+	return {
+		getMergeRequests,
+		getMergeRequest,
+		getMergeRequestWithActivityLog,
+		createMergeRequest,
+		updateMergeRequest,
+		requestReview,
+		approveMergeRequest,
+		requestChangesMergeRequest,
+		mergeMergeRequest,
+		getMergeRequestConflicts
+	};
+};
+//#endregion
+//#region src/clients/storage/branches/branches.ts
+/**
+* Every `/v2/storage/dev-branches` type below is asserted in, because the spec models none of this
+* contract. What it needs, per operation:
+*
+* - `GET /dev-branches` (`DevBranchesListAction`)
+*   - response: contentless `default` → really `DevBranch[]`
+* - `POST /dev-branches` (`DevBranchCreateAction`)
+*   - body: `CreateDevBranchRequest` is `Record<string, never>` → really `{ name, description? }`
+*   - response: contentless `default` → really a `devBranchCreate` job
+*   - duplicate: also declared on `/dev-branches/` (trailing slash); drop it
+* - `PUT /dev-branches/{id}` (`DevBranchUpdateAction`)
+*   - body: `UpdateDevBranchRequest` is `Record<string, never>` → really `{ name, description? }`
+*   - response: contentless `default` → really a `DevBranch`
+*   - path: `id` is a `string` → really a number
+* - `DELETE /dev-branches/{id}` (`DevBranchDeleteAction`)
+*   - response: contentless `default` → really a `devBranchDelete` job
+*   - path: `id` is a `string` → really a number
+*
+* A contentless `default` response makes the generated return type the response envelope
+* (`{ headers, content?: never }`) instead of a payload, which is why all four returns are asserted.
+* The `{id}` deviation is the one that needs no assertion — the id goes into the URL, so `String`
+* converts it and the wire is identical.
+*/
+const createBranches = (client, poller) => {
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/GET/v2/storage/dev-branches
+	*/
+	const getDevBranches = async (signal) => {
+		const { data } = await client.get("/v2/storage/dev-branches", {}, { signal });
+		return data;
+	};
+	/**
+	* Creates a development branch. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/POST/v2/storage/dev-branches
+	*/
+	const createDevBranchAsync = async (body) => {
+		const { data } = await client.post("/v2/storage/dev-branches", { body });
+		return data;
+	};
+	/**
+	* Creates a development branch and waits for the job to finish.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/POST/v2/storage/dev-branches
+	*/
+	const createDevBranchAndWait = async (body, options) => {
+		return poller(await createDevBranchAsync(body), options).start();
+	};
+	/**
+	* Renames a development branch or changes its description.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/PUT/v2/storage/dev-branches/{id}
+	*/
+	const updateDevBranch = async ({ id, name, description }) => {
+		const { data } = await client.put("/v2/storage/dev-branches/{id}", {
+			path: { id: String(id) },
+			body: {
+				name,
+				description
+			}
+		});
+		return data;
+	};
+	/**
+	* Deletes a development branch. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/DELETE/v2/storage/dev-branches/{id}
+	*/
+	const deleteDevBranchAsync = async (id) => {
+		const { data } = await client.delete("/v2/storage/dev-branches/{id}", { path: { id: String(id) } });
+		return data;
+	};
+	/**
+	* Deletes a development branch and waits for the job to finish.
+	*
+	* - Resolves with how the wait ended, so nothing throws: `done` carries the finished
+	*   `devBranchDelete` job.
+	* - A job that ended as `error` is a `done` wait carrying a failed job — it finished. `timedOut`,
+	*   `exhausted`, `aborted` and `errored` are the endings with no job to read.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/dev-branches/DELETE/v2/storage/dev-branches/{id}
+	*/
+	const deleteDevBranchAndWait = async (id, options) => {
+		return poller(await deleteDevBranchAsync(id), options).start();
+	};
+	/**
+	* Returns every metadata record on a branch. The branch is the object here, so `branchId` is the
+	* thing being addressed rather than the branch a request is scoped to.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/metadata/GET/v2/storage/branch/{branchId}/metadata
+	*/
+	const getDevBranchMetadata = async (branchId, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/metadata", { path: { branchId } }, { signal });
+		return data;
+	};
+	/**
+	* Adds or updates metadata on a branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/metadata/POST/v2/storage/branch/{branchId}/metadata
+	*/
+	const saveDevBranchMetadata = async ({ branchId, metadata }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/metadata", {
+			path: { branchId },
+			body: { metadata }
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a single metadata entry from a branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/metadata/DELETE/v2/storage/branch/{branchId}/metadata/{metadataId}
+	*/
+	const deleteDevBranchMetadata = async ({ branchId, metadataId }, signal) => {
+		await client.delete("/v2/storage/branch/{branchId}/metadata/{metadataId}", { path: {
+			branchId,
+			metadataId
+		} }, { signal });
+	};
+	return {
+		getDevBranches,
+		updateDevBranch,
+		createDevBranchAsync,
+		createDevBranchAndWait,
+		deleteDevBranchAsync,
+		deleteDevBranchAndWait,
+		getDevBranchMetadata,
+		saveDevBranchMetadata,
+		deleteDevBranchMetadata
+	};
+};
+//#endregion
+//#region src/clients/storage/bucketExternal/bucketExternal.ts
+/**
+* An external bucket wraps a schema that already exists in the project's backend (Snowflake or
+* BigQuery) rather than one Keboola created. Registering it is what makes the rest of this namespace
+* apply: only an external bucket needs its table metadata refreshed, manually or on a cron.
+*
+* Two spec mismatches recur and account for the assertions below:
+* - **jobs** — the spec's `JobResponse` is a flat shape with `status: string`, while `Job<T>` is a
+*   discriminated union over `status` carrying typed `results`. Every job return is asserted, whether
+*   the operation declares a `JobResponse` or no body at all.
+* - **`async` query** — `registerBucketAsync` is invoked with `async: true` but declares
+*   `query: never`.
+*
+* What the Storage spec needs, per operation:
+*
+* - `POST /buckets/register` (`BucketRegisterAction`)
+*   - body: `RegisterExistingBucketRequest` is stubbed → really `RegisterBucketBody`
+*   - query: `never` → really accepts `async`
+*   - response: contentless `default` → really a `bucketRegister` job
+* - `PUT /buckets/{bucketId}/refresh` (`BucketRefreshAction`)
+*   - response: 202 `JobResponse` → really a `bucketRefresh` job
+* - `POST /branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh` (`ScheduleRefreshAction`)
+*   - response: contentless `default` → really a `ScheduledTask`
+*
+* `GET /buckets/register-guide` is the one operation whose spec is already right — its query and
+* response types are generated, not asserted.
+*/
+const createBucketExternal = (openApiClient) => {
+	/**
+	* Registers an external bucket. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/POST/v2/storage/buckets/register
+	*/
+	const registerBucketAsync = async (body, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/buckets/register", {
+			query: { async: true },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Returns a markdown guide for registering an external bucket.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/GET/v2/storage/buckets/register-guide
+	*/
+	const getBucketRegistrationGuide = async (query, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/buckets/register-guide", { query }, {
+			signal,
+			queryArrayFormat: "brackets"
+		});
+		return data;
+	};
+	/**
+	* Refreshes an external bucket's table metadata. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/PUT/v2/storage/buckets/{bucketId}/refresh
+	*/
+	const refreshExternalBucketAsync = async ({ bucketId, ...query }, signal) => {
+		const { data } = await openApiClient.put("/v2/storage/buckets/{bucketId}/refresh", {
+			path: { bucketId },
+			query
+		}, { signal });
+		return data;
+	};
+	const createScheduledRefresh = async ({ branchId, bucketId, ...body }) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh", {
+			path: {
+				branchId,
+				bucketId
+			},
+			body
+		});
+		return data;
+	};
+	const deleteScheduledTask = async (taskId) => {
+		await openApiClient.delete("/v2/storage/scheduled-tasks/{taskId}", { path: { taskId } });
+	};
+	return {
+		registerBucketAsync,
+		getBucketRegistrationGuide,
+		refreshExternalBucketAsync,
+		createScheduledRefresh,
+		deleteScheduledTask
+	};
+};
+//#endregion
+//#region src/clients/storage/bucketListings/utils.ts
+/**
+* The two halves of the `bigquery.subscribers` wire format: a GCP IAM principal, which the Storage
+* spec documents as "prefixed with `user:` or `group:`". The write path uses `toBackendSubscribers`;
+* reads hand back the raw `string[]`, so a consumer that renders or edits subscribers decodes with
+* `fromBackendSubscribers` rather than re-deriving the prefix rule.
+*/
+const toBackendSubscribers = (subscribers) => subscribers.map((s) => `${s.type}:${s.email}`);
+const fromBackendSubscribers = (raw) => {
+	const result = [];
+	for (const entry of raw) {
+		const colon = entry.indexOf(":");
+		if (colon === -1) continue;
+		const prefix = entry.slice(0, colon);
+		const email = entry.slice(colon + 1);
+		if (prefix !== "user" && prefix !== "group") continue;
+		if (email.length === 0) continue;
+		result.push({
+			type: prefix,
+			email
+		});
+	}
+	return result;
+};
+/**
+* Builds the PATCH body for a listing update.
+*
+* Every field is copied only when the caller actually supplied it, because `description` carries
+* three distinct meanings: absent means "leave it alone", `null` means "clear it", and a string
+* means "set it". Evaluating the coercion unconditionally would turn an omitted description into a
+* `null` and silently clear it.
+*
+* Throws when nothing was supplied: the backend answers an empty PATCH with a job that lands in
+* `success` without changing anything, so a caller would poll it and report a save that never
+* happened. Gate the call on the form's "dirty" state rather than relying on this.
+*
+* Do not "normalize" the `exposure*` names without coordinating with the bucket-listing backend
+* owner.
+*/
+const toUpdateListingBody = (input) => {
+	const body = {};
+	if (input.name !== void 0) body.exposureName = input.name;
+	if (input.description !== void 0) body.exposureDescription = input.description?.trim() || null;
+	if (input.subscribers !== void 0) body.bigquery = { subscribers: toBackendSubscribers(input.subscribers) };
+	if (Object.keys(body).length === 0) throw new Error("updateListingAsync requires at least one field");
+	return body;
+};
+//#endregion
+//#region src/clients/storage/bucketListings/bucketListings.ts
+/**
+* A bucket listing (exposure) publishes a bucket to a marketplace — BigQuery Analytics Hub is the
+* only backend today, which is why every write carries a `bigquery` key.
+*
+* What the Storage spec needs, per operation:
+*
+* - `POST` / `PATCH` / `DELETE /buckets/{bucketId}/listing`
+*   - response: 202 `JobResponse` → really `bucketListingCreate` / `bucketListingUpdate` /
+*     `bucketListingDelete` jobs. The spec's `JobResponse` is a flat shape with `status: string`,
+*     while `Job<T>` is a discriminated union over `status` carrying typed `results`, so each is
+*     asserted.
+*
+* `GET /buckets/{bucketId}/listing` and `GET /listings` are the operations whose specs are already
+* right — their query and response types are generated, not asserted.
+*/
+const createBucketListings = (openApiClient) => {
+	/**
+	* Reads a bucket's listing, or `null` when the bucket has none (the endpoint 404s for both "no
+	* bucket" and "no listing"). The response is the spec shape: `bigquery` is optional there — it is
+	* present only for a BigQuery bucket, the only backend today — and `subscribers` inside it are the
+	* raw `user:`/`group:`-prefixed principals, which `fromBackendSubscribers` decodes.
+	*/
+	const getListing = async (bucketId, signal) => {
+		try {
+			const { data } = await openApiClient.get("/v2/storage/buckets/{bucketId}/listing", { path: { bucketId } }, { signal });
+			return data;
+		} catch (error) {
+			if (isApiError(error) && error.response.status === 404) return null;
+			throw error;
+		}
+	};
+	const createListingAsync = async ({ bucketId, ...input }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/buckets/{bucketId}/listing", {
+			path: { bucketId },
+			body: {
+				listingName: input.name,
+				listingDescription: input.description?.trim() || null,
+				bigquery: {
+					listingId: input.listingId,
+					subscribers: toBackendSubscribers(input.subscribers)
+				}
+			}
+		}, { signal });
+		return data;
+	};
+	/**
+	* Update a bucket exposure. At least one of `name`, `description`, or
+	* `subscribers` must be provided — the SDK throws synchronously if all three
+	* are absent, since the backend would otherwise no-op a PATCH with an empty
+	* body and we'd return a job that's already in `success` with no actual
+	* change. Callers should gate the call against the form's "dirty" state.
+	*/
+	const updateListingAsync = async ({ bucketId, ...input }, signal) => {
+		const { data } = await openApiClient.patch("/v2/storage/buckets/{bucketId}/listing", {
+			path: { bucketId },
+			body: toUpdateListingBody(input)
+		}, { signal });
+		return data;
+	};
+	const deleteListingAsync = async (bucketId, signal) => {
+		const { data } = await openApiClient.delete("/v2/storage/buckets/{bucketId}/listing", { path: { bucketId } }, { signal });
+		return data;
+	};
+	/** Every listing the token can manage. Rows carry `bucketId`, unlike the detail response. */
+	const getListings = async (signal) => {
+		const { data } = await openApiClient.get("/v2/storage/listings", {}, { signal });
+		return data;
+	};
+	return {
+		getListing,
+		createListingAsync,
+		updateListingAsync,
+		deleteListingAsync,
+		getListings
+	};
+};
+//#endregion
+//#region src/clients/storage/buckets/buckets.ts
+/**
+* Everything here runs through the OpenAPI client except `updateBucket`, which cannot: the spec
+* declares no `put` on `/v2/storage/buckets/{bucketId}` (nor on the branch variant), so the operation
+* is missing outright rather than mistyped. That one keeps the generic client, which is why this
+* factory still takes both.
+*
+* One mismatch recurs: the spec's `JobResponse` is a flat shape with `status: string`, while `Job<T>`
+* is a discriminated union over `status` carrying typed `results`, so every job return is asserted.
+*
+* What the Storage spec needs, per operation:
+*
+* - `PUT /buckets/{bucketId}` — **operation missing entirely**; really takes `UpdateBucketBody`
+*   (`displayName` / `description` / `color`) and answers a bucket detail
+* - `GET /branch/{branchId}/buckets` (`BucketsListAction`)
+*   - query: `include` is a `string` → really a repeatable list, sent comma-joined
+*   - response: `BucketCreateResponse[]` → really `Bucket[]` (a listing row, not a create result)
+* - `POST /buckets` (`BucketCreateAction`)
+*   - response: 201 `BucketCreateResponse` → really a bucket detail
+* - `DELETE /buckets/{bucketId}` (`BucketDeleteAction`)
+*   - response: 204 wins over the 202 `JobResponse` in success-code precedence, so the async variant's
+*     job is asserted
+* - `POST /buckets/{bucketId}/owner` (`BucketOwnerUpdateAction`)
+*   - body: `BucketOwnerUpdateRequest` is stubbed → really `{ email } | { id }`
+* */
+const createBuckets = (openApiClient, client) => {
+	const getBuckets = async ({ branchId, ...query }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/buckets", {
+			path: { branchId },
+			query
+		}, {
+			signal,
+			queryArrayFormat: "comma"
+		});
+		return data;
+	};
+	/**
+	* Returns a bucket from the given branch. A dev branch only contains the buckets created or
+	* pulled into it, so a production bucket must be read with the default branch id.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/GET/v2/storage/branch/{branchId}/buckets/{bucketId}
+	*/
+	const getBucket = async ({ branchId, bucketId, include }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/buckets/{bucketId}", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { include: include?.join(",") }
+		}, { signal });
+		return data;
+	};
+	const createBucket = async (body) => {
+		const { data } = await openApiClient.post("/v2/storage/buckets", { body });
+		return data;
+	};
+	const updateBucket = async ({ bucketId, ...body }) => {
+		const { data } = await client.put(`/v2/storage/buckets/{id}`, {
+			path: { id: bucketId },
+			body
+		});
+		return data;
+	};
+	/**
+	* Deletes a bucket synchronously.
+	*
+	* Refused outright on the stacks we test against (`400 storage.buckets.syncDeleteDisabled`,
+	* "Synchronous drop is not supported, use async call") — prefer `deleteBucketAsync` below.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/DELETE/v2/storage/buckets/{bucketId}
+	*/
+	const deleteBucket = async (id) => {
+		await openApiClient.delete("/v2/storage/buckets/{bucketId}", { path: { bucketId: id } });
+	};
+	/**
+	* Deletes a bucket asynchronously and returns a job to poll.
+	* Required on GCP stacks where synchronous bucket deletion is not supported.
+	*
+	* `force` deletes all tables inside the bucket before removing it.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/DELETE/v2/storage/buckets/{bucketId}
+	*/
+	const deleteBucketAsync = async ({ bucketId, ...query }) => {
+		const { data } = await openApiClient.delete("/v2/storage/buckets/{bucketId}", {
+			path: { bucketId },
+			query: {
+				async: true,
+				...query
+			}
+		});
+		return data;
+	};
+	/**
+	* Returns the owner of a bucket in the given branch.
+	*
+	* A bucket has no owner until one is assigned — reading it on a fresh bucket answers
+	* `404 storage.bucket.ownerNotFound`, so call `updateBucketOwner` first (or handle the 404 as
+	* "unassigned" rather than as a missing bucket).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/GET/v2/storage/branch/{branchId}/buckets/{bucketId}/owner
+	*/
+	const getBucketOwner = async ({ branchId, bucketId }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/buckets/{bucketId}/owner", { path: {
+			branchId,
+			bucketId
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Changes the owner of a bucket (by `id` or `email`).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/buckets/{bucketId}/owner
+	*/
+	const updateBucketOwner = async ({ bucketId, ...body }, signal) => {
+		await openApiClient.post("/v2/storage/buckets/{bucketId}/owner", {
+			path: { bucketId },
+			body
+		}, { signal });
+	};
+	/**
+	* Adds or updates metadata on a bucket in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata
+	*/
+	const saveBucketMetadata = async ({ branchId, bucketId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata", {
+			path: {
+				branchId,
+				bucketId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a single metadata entry from a bucket in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/DELETE/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata/{metadataId}
+	*/
+	const deleteBucketMetadata = async ({ branchId, bucketId, metadataId }, signal) => {
+		await openApiClient.delete("/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata/{metadataId}", { path: {
+			branchId,
+			bucketId,
+			metadataId
+		} }, { signal });
+	};
+	return {
+		getBuckets,
+		getBucket,
+		createBucket,
+		updateBucket,
+		deleteBucket,
+		deleteBucketAsync,
+		getBucketOwner,
+		updateBucketOwner,
+		saveBucketMetadata,
+		deleteBucketMetadata
+	};
+};
+//#endregion
+//#region src/clients/storage/bucketSharing/bucketSharing.ts
+/**
+* Two spec mismatches recur here and account for every assertion below:
+* - **jobs** — the spec's `JobResponse` is a flat shape with `status: string`, while `Job<T>` is a
+*   discriminated union over `status` carrying typed `results`. Every job return is asserted, whether
+*   the operation declares a `JobResponse` or no body at all.
+* - **`async` query** — all six share/unshare operations are invoked with `async: true` but declare
+*   `query: never`.
+*
+* What the Storage spec needs, per operation:
+*
+* - `POST /branch/{branchId}/buckets/{bucketId}/share-organization` / `-organization-project`
+*   - query: `never` → really accepts `async`
+*   - response: `BucketShareOrganizationResponse` / `…ProjectResponse` → really share jobs
+* - `POST /branch/{branchId}/buckets/{bucketId}/share-to-projects` / `-to-users`
+*   - query: `never` → really accepts `async`
+*   - body: `CreateBucketSharingToProjectsRequest` / `…ToUsersRequest` are stubbed
+*     (`Record<string, never>`) → really `{ targetProjectIds }` / `{ targetUsers }`
+*   - response: contentless `default` → really `bucketShareToProjects` / `bucketShareToAdmins` jobs
+* - `DELETE /branch/{branchId}/buckets/{bucketId}/share` (`BucketShareDeleteAction`)
+*   - query: `never` → really accepts `async`
+*   - response: `BucketShareDeleteResponse` → really a `bucketRemoveShare` job
+* - `DELETE /branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}` (`BucketForceUnlinkAction`)
+*   - query: `never` → really accepts `async`
+*   - path: `linkedProjectId` is a `number` → really a string
+*   - response: 202 `JobResponse` → really a `bucketForceUnlink` job
+* - `POST /buckets` (`BucketCreateAction`) — the link half of a create-or-link endpoint
+*   - response: the 201 "created or linked synchronously" wins over the 202 in success-code
+*     precedence, so the async variant's `bucketLink` job is asserted
+* - `GET /shared-buckets` (`SharedBucketsListAction`)
+*   - response: `Record<string, never>[]` → really a shared-bucket listing. This one is *not*
+*     asserted, so `SharedBuckets` is currently an empty-object array and callers get nothing useful.
+*/
+const createBucketSharing = (openApiClient) => {
+	/**
+	* Shares a bucket with everyone in the organization. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization
+	*/
+	const shareBucketToOrganizationAsync = async ({ branchId, bucketId }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { async: true }
+		}, { signal });
+		return data;
+	};
+	/**
+	* Shares a bucket with every project in the organization. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization-project
+	*/
+	const shareBucketToOrganizationProjectAsync = async ({ branchId, bucketId }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization-project", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { async: true }
+		}, { signal });
+		return data;
+	};
+	/**
+	* Shares a bucket with specific projects. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects
+	*/
+	const shareBucketToProjectsAsync = async ({ branchId, bucketId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { async: true },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Shares a bucket with specific users (by ID or e-mail). Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users
+	*/
+	const shareBucketToUsersAsync = async ({ branchId, bucketId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { async: true },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Stops sharing a bucket. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/DELETE/v2/storage/branch/{branchId}/buckets/{bucketId}/share
+	*/
+	const unshareBucketAsync = async ({ branchId, bucketId }, signal) => {
+		const { data } = await openApiClient.delete("/v2/storage/branch/{branchId}/buckets/{bucketId}/share", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query: { async: true }
+		}, { signal });
+		return data;
+	};
+	/**
+	* Force-unlinks a bucket from a linked project. Async — returns a job to poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/DELETE/v2/storage/branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}
+	*/
+	const forceUnlinkBucketAsync = async ({ branchId, bucketId, linkedProjectId }, signal) => {
+		const { data } = await openApiClient.delete("/v2/storage/branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}", {
+			path: {
+				branchId,
+				bucketId,
+				linkedProjectId
+			},
+			query: { async: true }
+		}, { signal });
+		return data;
+	};
+	/**
+	* Links a bucket shared with this project into it. Async — returns a job to poll, whose `results`
+	* is the new bucket.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/buckets
+	*/
+	const linkBucketAsync = async (body, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/buckets", {
+			query: { async: true },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Lists buckets shared with the current project.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/shared-buckets/GET/v2/storage/shared-buckets
+	*/
+	const sharedBuckets = async (query, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/shared-buckets", { query }, { signal });
+		return data;
+	};
+	return {
+		shareBucketToOrganizationAsync,
+		shareBucketToOrganizationProjectAsync,
+		shareBucketToProjectsAsync,
+		shareBucketToUsersAsync,
+		unshareBucketAsync,
+		forceUnlinkBucketAsync,
+		linkBucketAsync,
+		sharedBuckets
+	};
+};
+//#endregion
+//#region src/clients/storage/columns/columns.ts
+/**
+* Every job return below is asserted in: the spec's `JobResponse` is a flat shape with
+* `status: string`, while `Job<T>` is a discriminated union over `status` carrying typed `results`.
+* That mismatch applies to both operations that declare a `JobResponse` and those that declare no
+* response body at all. What the Storage spec needs, per operation:
+*
+* - `POST /branch/{branchId}/tables/{id}/columns` (`ColumnCreateAction`)
+*   - body: none of `ColumnCreateRequest` / `SnowflakeAddColumnToTableRequest` /
+*     `BigqueryAddColumnToTableRequest` declares `basetype`, and they type `definition.length` as a
+*     `number` → really a string (a decimal length is sent as `'38,0'`)
+*   - response: 202 is contentless → really a `tableColumnAdd` job
+* - `DELETE /branch/{branchId}/tables/{tableId}/columns/{columnName}` (`ColumnDeleteAction`)
+*   - response: 202 declares `JobResponse` → really a `tableColumnDelete` job
+* - `POST /branch/{branchId}/tables/{tableId}/primary-key` (`PrimaryKeyCreateAction`)
+*   - body: `CreatePrimaryKeyRequest.skipDuplicatesCheck` is required → really optional (it has a
+*     documented `@default false`, so a caller omitting it is valid)
+*   - response: 202 is contentless → really a `tablePrimaryKeyAdd` job
+* - `DELETE /branch/{branchId}/tables/{tableId}/primary-key` (`PrimaryKeyDeleteAction`)
+*   - response: 202 declares `JobResponse` → really a `tablePrimaryKeyDelete` job
+*/
+const createColumns = (client) => {
+	/**
+	* Adds a column to a table. Async — returns a job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/columns/POST/v2/storage/branch/{branchId}/tables/{id}/columns
+	*/
+	const addTableColumnAsync = async ({ branchId, id, ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/tables/{id}/columns", {
+			path: {
+				branchId,
+				id
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Drops a column from a table. Async — returns a job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/columns/DELETE/v2/storage/branch/{branchId}/tables/{tableId}/columns/{columnName}
+	*/
+	const deleteTableColumnAsync = async ({ branchId, tableId, columnName, ...query }, signal) => {
+		const { data } = await client.delete("/v2/storage/branch/{branchId}/tables/{tableId}/columns/{columnName}", {
+			path: {
+				branchId,
+				tableId,
+				columnName
+			},
+			query
+		}, { signal });
+		return data;
+	};
+	/**
+	* Sets the primary key of a table. Async — returns a job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/POST/v2/storage/branch/{branchId}/tables/{tableId}/primary-key
+	*/
+	const createTablePrimaryKeyAsync = async ({ branchId, tableId, ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/tables/{tableId}/primary-key", {
+			path: {
+				branchId,
+				tableId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Removes the primary key of a table. Async — returns a job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/DELETE/v2/storage/branch/{branchId}/tables/{tableId}/primary-key
+	*/
+	const removeTablePrimaryKeyAsync = async ({ branchId, tableId }, signal) => {
+		const { data } = await client.delete("/v2/storage/branch/{branchId}/tables/{tableId}/primary-key", { path: {
+			branchId,
+			tableId
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Adds or updates metadata on a column in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/columns/POST/v2/storage/branch/{branchId}/columns/{id}/metadata
+	*/
+	const saveColumnMetadata = async ({ branchId, columnId, ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/columns/{id}/metadata", {
+			path: {
+				branchId,
+				id: columnId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a single metadata entry from a column in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/columns/DELETE/v2/storage/branch/{branchId}/columns/{id}/metadata/{metadataId}
+	*/
+	const deleteColumnMetadata = async ({ branchId, columnId, metadataId }, signal) => {
+		await client.delete("/v2/storage/branch/{branchId}/columns/{id}/metadata/{metadataId}", { path: {
+			branchId,
+			id: columnId,
+			metadataId
+		} }, { signal });
+	};
+	return {
+		addTableColumnAsync,
+		deleteTableColumnAsync,
+		createTablePrimaryKeyAsync,
+		removeTablePrimaryKeyAsync,
+		saveColumnMetadata,
+		deleteColumnMetadata
+	};
+};
+//#endregion
+//#region src/clients/storage/components/components.ts
+const createComponents = (client) => {
+	const getComponent = async ({ componentId, branchId = "default" }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}", { path: {
+			componentId,
+			branchId
+		} }, { signal });
+		return data;
+	};
+	const getComponents = async ({ branchId = "default", ...query } = {}, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components", {
+			path: { branchId: String(branchId) },
+			query
+		}, {
+			signal,
+			queryArrayFormat: "comma"
+		});
+		return data;
+	};
+	return {
+		getComponent,
+		getComponents
+	};
+};
+//#endregion
+//#region src/clients/storage/configurationMetadata/configurationMetadata.ts
+const createConfigurationMetadata = (client) => {
+	const getConfigurationMetadata = async ({ branchId = "default", componentId, configurationId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata", { path: {
+			branchId,
+			componentId,
+			configurationId
+		} }, { signal });
+		return data;
+	};
+	/** Create or update configuration metadata (e.g. `KBC.configuration.folderName`). */
+	const saveConfigurationMetadata = async ({ branchId = "default", componentId, configurationId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata", {
+			path: {
+				branchId,
+				componentId,
+				configurationId
+			},
+			body
+		});
+		return data;
+	};
+	/** Only available on the default branch — a dev branch answers 501. */
+	const deleteConfigurationMetadata = async ({ branchId = "default", componentId, configurationId, metadataId }, signal) => {
+		await client.delete("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata/{metadataId}", { path: {
+			branchId,
+			componentId,
+			configurationId,
+			metadataId
+		} }, { signal });
+	};
+	return {
+		getConfigurationMetadata,
+		saveConfigurationMetadata,
+		deleteConfigurationMetadata
+	};
+};
+//#endregion
+//#region src/clients/storage/configurationRows/configurationRows.ts
+const createConfigurationRows = (client) => {
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/POST/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows
+	*/
+	const createConfigurationRow = async ({ branchId = "default", componentId, configurationId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows", {
+			path: {
+				branchId,
+				componentId,
+				configurationId
+			},
+			body
+		});
+		return data;
+	};
+	/**
+	* NOTE: Do not run this method concurrently; BE will return 500 server errors under load due to a BE bottleneck with IDs allocation.
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/POST/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows
+	*/
+	const createConfigurationRows = async ({ branchId = "default", componentId, configurationId, data }, options) => {
+		return series({
+			items: data,
+			process: (rowBody) => {
+				return createConfigurationRow({
+					branchId,
+					componentId,
+					configurationId,
+					...rowBody
+				});
+			},
+			middlewares: options?.middlewares
+		});
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/GET/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}
+	*/
+	const getConfigurationRow = async ({ branchId = "default", ...path }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}", { path: {
+			branchId,
+			...path
+		} }, { signal });
+		return data;
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/PUT/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}
+	*/
+	const updateConfigurationRow = async ({ branchId = "default", componentId, configurationId, rowId, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}", {
+			path: {
+				branchId,
+				componentId,
+				configurationId,
+				rowId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/PUT/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/state
+	*/
+	const updateConfigurationRowState = async ({ branchId = "default", componentId, configurationId, rowId, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/state", {
+			path: {
+				branchId,
+				componentId,
+				configurationId,
+				rowId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/DELETE/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}
+	*/
+	const deleteConfigurationRow = async ({ changeDescription, ...path }) => {
+		await client.delete("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}", {
+			path,
+			body: { changeDescription }
+		});
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configuration-rows/DELETE/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}
+	*/
+	const deleteConfigurationRows = async ({ rowIds, changeDescription, ...input }, options) => {
+		await concurrent({
+			items: rowIds,
+			process: (rowId) => {
+				const resolvedDescription = typeof changeDescription === "string" ? changeDescription : changeDescription?.(rowId);
+				return deleteConfigurationRow({
+					rowId,
+					changeDescription: resolvedDescription,
+					...input
+				});
+			},
+			concurrency: 5,
+			middlewares: options?.middlewares
+		});
+	};
+	return {
+		createConfigurationRow,
+		createConfigurationRows,
+		getConfigurationRow,
+		updateConfigurationRow,
+		updateConfigurationRowState,
+		deleteConfigurationRow,
+		deleteConfigurationRows
+	};
+};
+//#endregion
+//#region src/clients/storage/configurations/utils.ts
+/**
+* `expectedVersion` is the `version` field of the configuration the caller read, sent back as the
+* `If-Match` header so the write is conditional on nothing having changed since. What Storage does
+* with it:
+*
+* 1. Header omitted (`{}`) — no precondition, the write applies whatever the current version is.
+*    `purgeConfiguration` is the exception and answers 428, which is why its `expectedVersion` is
+*    required rather than optional.
+* 2. Version still current — the write applies.
+* 3. Version moved on since it was read — 412, and nothing is written.
+* 4. Value unusable — 400. Storage wants a strong entity tag, so the quotes are part of the value;
+*    a bare number, a weak validator or a tag list are all rejected.
+*/
+const createVersionPrecondition = (expectedVersion) => expectedVersion === void 0 ? {} : { [HttpHeader.IF_MATCH]: `"${expectedVersion}"` };
+/**
+* The `workspaceOutputMappingSync` job a configuration update enqueued.
+*
+* - Storage reports it in a header, not in the response body.
+* - `null` means there is no job to wait for, not that the write failed.
+* - Components outside Storage's allow-list get no job — `workspaceId` is ignored for them.
+*/
+const parseSyncJobId = (headers) => {
+	const jobId = Number(headers.get(KeboolaHttpHeader.STORAGE_API_JOB_ID));
+	return Number.isInteger(jobId) && jobId > 0 ? jobId : null;
+};
+//#endregion
+//#region src/clients/storage/configurations/configurations.ts
+const createConfigurations = (client) => {
+	const getConfiguration = async ({ componentId, configId, branchId = "default" }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}", { path: {
+			componentId,
+			configurationId: configId,
+			branchId: String(branchId)
+		} }, { signal });
+		return data;
+	};
+	const getConfigurationDiff = async ({ componentId, configId, branchId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/diff", { path: {
+			componentId,
+			configurationId: configId,
+			branchId: String(branchId)
+		} }, { signal });
+		return data;
+	};
+	const rebaseConfiguration = async ({ branchId, componentId, configId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rebase", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId: configId
+			},
+			body
+		});
+		return data;
+	};
+	/**
+	* Resolve a merge conflict by deleting the configuration — the same rebase
+	* endpoint as `rebaseConfiguration`, but with an empty `diff` envelope. The
+	* dev-branch configuration is re-anchored onto the given default-branch
+	* `version` and its head version becomes a tombstone (soft delete). Returns
+	* the deleted configuration.
+	*/
+	const rebaseConfigurationToDeleted = async ({ branchId, componentId, configId, version }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rebase", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId: configId
+			},
+			body: {
+				version,
+				diff: {}
+			}
+		});
+		return data;
+	};
+	const createConfiguration = async ({ branchId = "default", componentId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs", {
+			path: {
+				branchId: String(branchId),
+				componentId
+			},
+			body
+		});
+		return data;
+	};
+	/**
+	* Updates an existing configuration. Only the fields provided are sent.
+	*
+	* - Resolves once the configuration is written.
+	* - Sending `workspaceId` also asks Storage to sync that workspace's output mapping against the
+	*   saved configuration. That part runs as a job: poll `syncJobId` through `jobs.getJob` when it
+	*   has to land before the caller reports success.
+	* - A `workspaceId` not linked to this component and configuration is rejected with 400, before
+	*   the configuration is written.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configurations/PUT/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}
+	*/
+	const updateConfiguration = async ({ branchId = "default", componentId, configId, configuration, workspaceId, ...rest }, signal) => {
+		const body = {
+			...rest,
+			configuration
+		};
+		const { data, response } = await client.put("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId: configId
+			},
+			query: { workspaceId },
+			body
+		}, { signal });
+		return {
+			configuration: data,
+			syncJobId: parseSyncJobId(response.headers)
+		};
+	};
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configurations/PUT/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/state
+	*/
+	const updateConfigurationState = async ({ branchId = "default", componentId, configId, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/state", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId: configId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Move a configuration to the trash — or, when it is in the trash already, purge it
+	* permanently. Pass `expectedVersion` to pin the version the delete was decided on;
+	* prefer `purgeConfiguration` when the permanent removal is the intent.
+	*/
+	const deleteConfiguration = async ({ branchId, componentId, configId, expectedVersion }) => {
+		await client.delete("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId: configId
+		} }, { headers: { ...createVersionPrecondition(expectedVersion) } });
+	};
+	/**
+	* Permanently remove a trashed configuration, including its versions, rows and metadata.
+	* Unlike a second `deleteConfiguration`, this never falls back to a soft delete: purging a
+	* live configuration is rejected (400 `notInTrash`) rather than trashing it. Default branch
+	* only, and the token needs `canPurgeTrash`.
+	*/
+	const purgeConfiguration = async ({ branchId = "default", componentId, configId, expectedVersion }) => {
+		await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/purge", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId: configId
+		} }, { headers: { ...createVersionPrecondition(expectedVersion) } });
+	};
+	/**
+	* Purge configurations across components in one bounded fan-out. Like every `concurrent` caller
+	* it stops at the first rejection, and here that is a case to plan for rather than an edge: a
+	* stale `expectedVersion` (412) abandons the rest of the queue, so re-read the trash before
+	* offering another attempt.
+	*
+	* Emptying a trash is the whole-collection case this exists for, which `concurrent`'s default of
+	* 2 would walk through two configurations at a time.
+	*/
+	const purgeConfigurations = async ({ branchId, configs }) => {
+		await concurrent({
+			items: configs,
+			concurrency: 10,
+			process: (config) => purgeConfiguration({
+				branchId,
+				...config
+			})
+		});
+	};
+	/** Restore a trashed configuration. */
+	const restoreConfiguration = async ({ branchId = "default", componentId, configId }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/restore", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId: configId
+		} });
+		return data;
+	};
+	/**
+	* Reset a dev-branch configuration back to its default-branch (production) version.
+	*
+	* The spec is right: the endpoint answers with an empty body, confirmed against the live API by
+	* the nightly smoke (`integration/storageConfigurationLifecycle.smoke.ts`). It used to be typed as
+	* resolving to the configuration, so every caller reading a field off the result was reading
+	* `undefined`. Re-read the configuration to observe the reset.
+	*
+	* Dev-branch only — the API answers 501 on `default`.
+	*/
+	const resetConfigurationToDefault = async ({ branchId = "default", componentId, configId }) => {
+		await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/reset-to-default", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId: configId
+		} });
+	};
+	const deleteConfigurations = async ({ configIds, ...rest }) => {
+		await concurrent({
+			items: configIds,
+			process: async (configId) => deleteConfiguration({
+				...rest,
+				configId
+			})
+		});
+	};
+	const getConfigurations = async ({ componentId, branchId = "default" }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs", { path: {
+			componentId,
+			branchId: String(branchId)
+		} }, { signal });
+		return data;
+	};
+	const searchComponentConfigurations = async ({ branchId = "default", include, ...query } = {}, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/search/component-configurations", {
+			path: { branchId: String(branchId) },
+			query: {
+				...query,
+				...include?.length && { include: include.join(",") }
+			}
+		}, { signal });
+		return data;
+	};
+	return {
+		createConfiguration,
+		updateConfiguration,
+		updateConfigurationState,
+		getConfiguration,
+		getConfigurationDiff,
+		rebaseConfiguration,
+		rebaseConfigurationToDeleted,
+		deleteConfiguration,
+		deleteConfigurations,
+		purgeConfiguration,
+		purgeConfigurations,
+		getConfigurations,
+		restoreConfiguration,
+		resetConfigurationToDefault,
+		searchComponentConfigurations
+	};
+};
+//#endregion
+//#region src/clients/storage/configurationVersions/configurationVersions.ts
+const createConfigurationVersions = (client) => {
+	const getConfigurationVersions = async ({ branchId, componentId, configurationId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId
+		} }, { signal });
+		return data;
+	};
+	const getConfigurationVersion = async ({ branchId, componentId, configurationId, versionId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId,
+			versionId: String(versionId)
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Roll a configuration back to one of its versions.
+	*
+	* A rollback is itself a new version, not a rewind of the history, and the endpoint answers with
+	* only that number — no configuration body. Re-read the configuration to observe the result.
+	*/
+	const rollbackConfigurationToVersion = async ({ branchId = "default", componentId, configurationId, versionId }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/rollback", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId,
+				versionId: String(versionId)
+			},
+			body: {}
+		});
+		return data;
+	};
+	/**
+	* Server-side copy of a configuration from one of its versions. Preserves the
+	* full configuration including rows — unlike a read-then-create, which would
+	* only carry the top-level config body.
+	*
+	* The endpoint answers with only the new configuration's id; read it back for the body.
+	*/
+	const copyConfigurationFromVersion = async ({ branchId = "default", componentId, configurationId, versionId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/create", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId,
+				versionId: String(versionId)
+			},
+			body
+		});
+		return data;
+	};
+	const getConfigurationRowVersions = async ({ branchId, componentId, configurationId, rowId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId,
+			rowId
+		} }, { signal });
+		return data;
+	};
+	const getConfigurationRowVersion = async ({ branchId, componentId, configurationId, rowId, versionId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}", { path: {
+			branchId: String(branchId),
+			componentId,
+			configurationId,
+			rowId,
+			versionId: String(versionId)
+		} }, { signal });
+		return data;
+	};
+	/** Roll a configuration row back to one of its versions. */
+	const rollbackConfigurationRowToVersion = async ({ branchId = "default", componentId, configurationId, rowId, versionId }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/rollback", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId,
+				rowId,
+				versionId: String(versionId)
+			},
+			body: {}
+		});
+		return data;
+	};
+	/**
+	* Server-side copy of a row from one of its versions into the same configuration.
+	* The endpoint takes no body, so the copy's name is the backend's to choose — a
+	* caller that wants a specific one follows up with a row update.
+	*/
+	const copyConfigurationRowFromVersion = async ({ branchId = "default", componentId, configurationId, rowId, versionId }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/create", {
+			path: {
+				branchId: String(branchId),
+				componentId,
+				configurationId,
+				rowId,
+				versionId: String(versionId)
+			},
+			body: {}
+		});
+		return data;
+	};
+	return {
+		getConfigurationVersions,
+		getConfigurationVersion,
+		rollbackConfigurationToVersion,
+		copyConfigurationFromVersion,
+		getConfigurationRowVersions,
+		getConfigurationRowVersion,
+		rollbackConfigurationRowToVersion,
+		copyConfigurationRowFromVersion
+	};
+};
+//#endregion
+//#region src/clients/storage/configurationWorkspaces/configurationWorkspaces.ts
+const createConfigurationWorkspaces = (client) => {
+	/**
+	* @link https://api.keboola.com/?service=storage#storage/tag/component-configurations/GET/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces
+	*/
+	const getConfigurationWorkspaces = async ({ componentId, branchId, configurationId }) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces", { path: {
+			componentId,
+			branchId,
+			configurationId
+		} });
+		return data;
+	};
+	const createConfigurationWorkspace = async ({ componentId, branchId, configurationId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces", {
+			path: {
+				componentId,
+				branchId,
+				configurationId
+			},
+			body
+		});
+		return data;
+	};
+	const createConfigurationWorkspaceJob = async ({ componentId, branchId, configurationId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces", {
+			path: {
+				componentId,
+				branchId,
+				configurationId
+			},
+			body,
+			query: { async: true }
+		});
+		return data;
+	};
+	return {
+		createConfigurationWorkspace,
+		createConfigurationWorkspaceJob,
+		getConfigurationWorkspaces
+	};
+};
+//#endregion
+//#region src/clients/storage/events/events.ts
+/**
+* Every endpoint here is the branched variant, and `branchId` falls back to `default`.
+*
+* - The unbranched twins (`/v2/storage/events`, `/v2/storage/events/{eventId}`) answer the same
+*   payloads; addressing one branch is the narrower request and the one every caller wants.
+* - Each response is asserted in: the spec declares `content?: never` on all four event operations,
+*   and types `params`, `results` and `performance` as bare `Record<string, never>` where it does not.
+*/
+const createEvents = (client) => {
+	/**
+	* Event feed of a branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/events/GET/v2/storage/branch/{branchId}/events
+	*/
+	const getEvents = async ({ branchId, ...query }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/events", {
+			path: { branchId },
+			query
+		}, { signal });
+		return data;
+	};
+	/**
+	* A single event. Ids are `uuid`s — the `id` a create answers with does not resolve here.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/events/GET/v2/storage/branch/{branchId}/events/{eventId}
+	*/
+	const getEvent = async ({ branchId, eventId }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/events/{eventId}", { path: {
+			branchId,
+			eventId
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Event feed of a table in the given branch. A dev branch only contains the tables created or
+	* pulled into it, so a production table's events must be read with the default branch id.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/events/GET/v2/storage/branch/{branchId}/tables/{tableId}/events
+	*/
+	const getTableEvents = async ({ branchId, tableId, ...query }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/tables/{tableId}/events", {
+			path: {
+				branchId,
+				tableId
+			},
+			query
+		}, { signal });
+		return data;
+	};
+	/**
+	* Event feed of a bucket in the given branch. Same payload as the table feed.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/events/GET/v2/storage/branch/{branchId}/buckets/{bucketId}/events
+	*/
+	const getBucketEvents = async ({ branchId, bucketId, ...query }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/buckets/{bucketId}/events", {
+			path: {
+				branchId,
+				bucketId
+			},
+			query
+		}, { signal });
+		return data;
+	};
+	/**
+	* Writes an event into a branch's feed.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/events/POST/v2/storage/branch/{branchId}/events
+	*/
+	const createEvent = async ({ branchId = "default", ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/events", {
+			path: { branchId },
+			body
+		}, { signal });
+		return data;
+	};
+	return {
+		getEvents,
+		getEvent,
+		getTableEvents,
+		getBucketEvents,
+		createEvent
+	};
+};
+//#endregion
+//#region src/clients/storage/files/files.ts
+/**
+* Two spec defects account for every assertion below:
+*
+* - Only the delete declares a response body; the other six answer a contentless `default`, so each
+*   return is asserted in from `./types`.
+* - `fileId` is a `number` on the delete and the content read, a `string` on the other four — one id,
+*   typed both ways, so the string arms take `String(fileId)`.
+*/
+const createFiles = (openApiClient) => {
+	const getFile = async (fileId, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/files/{fileId}", { path: { fileId: String(fileId) } }, { signal });
+		return data;
+	};
+	const getFiles = async (query, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/files", { query }, {
+			signal,
+			queryArrayFormat: "brackets"
+		});
+		return data;
+	};
+	const deleteFile = async (fileId) => {
+		await openApiClient.delete("/v2/storage/files/{fileId}", { path: { fileId } });
+	};
+	const addFileTag = async (fileId, tag) => {
+		await openApiClient.post("/v2/storage/files/{fileId}/tags", {
+			path: { fileId: String(fileId) },
+			body: { tag }
+		});
+	};
+	const getFileContent = async (fileId, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/files/{fileId}/content", { path: { fileId } }, { signal });
+		const content = data;
+		return typeof content === "string" ? content : JSON.stringify(content, null, 2);
+	};
+	const deleteFileTag = async (fileId, tagName) => {
+		await openApiClient.delete("/v2/storage/files/{fileId}/tags/{tagName}", { path: {
+			fileId: String(fileId),
+			tagName
+		} });
+	};
+	const prepareFile = async (body, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/files/prepare", { body }, { signal });
+		return data;
+	};
+	return {
+		getFile,
+		getFileContent,
+		getFiles,
+		deleteFile,
+		addFileTag,
+		deleteFileTag,
+		prepareFile
+	};
+};
+//#endregion
+//#region src/clients/storage/jobs/jobs.ts
+/**
+* Both returns are asserted in, and `Job<T>` is the contract to trust.
+*
+* - The spec's `JobResponse` is a flat shape with `status: string`; `Job<T>` is a discriminated union
+*   over `status` whose `results` is typed per operation.
+* - The detail operation declares a contentless `default` response, so its `data` is not a job at all
+*   as far as the schema is concerned.
+*/
+const createJobs = (openApiClient) => {
+	const getJob = async (jobId, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/jobs/{jobId}", { path: { jobId: String(jobId) } }, { signal });
+		return data;
+	};
+	const getJobs = async (query, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/jobs", { query }, {
+			signal,
+			queryArrayFormat: "brackets"
+		});
+		return data;
+	};
+	return {
+		getJob,
+		getJobs
+	};
+};
+//#endregion
+//#region src/clients/storage/poller.ts
+const DEFAULT_POLL_INTERVAL = 2e3;
+const createJobPoller = ({ getJob }) => ({ id, operationName }, { interval, maxAttempts, timeout, signal } = {}) => poller({
+	pollKey: ["storage.job", {
+		jobId: id,
+		operation: operationName
+	}],
+	pollFn: ({ pollKey: [, params], signal: pollSignal }) => getJob(params.jobId, pollSignal),
+	until: ({ data }) => jobStatus.storage.isTerminal(data.status),
+	backoff: {
+		type: "constant",
+		interval: interval ?? DEFAULT_POLL_INTERVAL
+	},
+	maxAttempts,
+	timeout,
+	signal
+});
+//#endregion
+//#region src/clients/storage/refreshTokenMiddleware.ts
+const isTokenRefreshEndpoint = (request) => {
+	const url = new URL(request.url);
+	return request.method === "POST" && /\/tokens\/[^/]+\/refresh$/.test(url.pathname);
+};
+const tryParseNewToken = (data) => {
+	if (data === null || typeof data !== "object") return null;
+	const token = data.token;
+	return typeof token === "string" ? token : null;
+};
+const createRefreshTokenMiddlware = ({ accessToken, onRefresh }) => {
+	let current = accessToken;
+	return (next) => async (request) => {
+		request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, current);
+		if (!isTokenRefreshEndpoint(request.request)) return next(request);
+		const response = await next(request);
+		const newToken = tryParseNewToken(response.data);
+		if (newToken === null) return response;
+		current = newToken;
+		onRefresh?.(current);
+		return response;
+	};
+};
+//#endregion
+//#region src/clients/storage/search/search.ts
+/**
+* Both responses are asserted in, because the spec stubs them:
+*
+* - `GET /v2/storage/global-search` (`SearchAction`) declares its 200 as `Record<string, never>` →
+*   really `{ all, items, byType, byProject }`
+* - `GET /v2/storage/search/tables` (`SearchTablesAction`) declares a contentless 200 → really
+*   `Table[]`
+*
+* Both query casts are type-only, so each query object reaches the wire exactly as the caller wrote
+* it. That matters for `global-search`: the spec names its repeatable filters `types[]` / `projectIds[]`
+* / `branchTypes[]` / `branchIds[]`, but this endpoint has always been called with the bare names,
+* which `qs` serializes as `types[0]=bucket&types[1]=table` — also an array to the backend. Renaming
+* the fields to satisfy the document would change what Storage receives, and no test would catch it.
+*/
+const createSearch = (client) => {
+	/**
+	* Project- and organization-wide search across buckets, tables, configurations, flows, ….
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/global-search/GET/v2/storage/global-search
+	*/
+	const globalSearch = async (query, signal) => {
+		const { data } = await client.get("/v2/storage/global-search", { query }, { signal });
+		return data;
+	};
+	/**
+	* Finds tables by a metadata key, value or provider, across the whole project.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/search/GET/v2/storage/search/tables
+	*/
+	const searchTables = async (query, signal) => {
+		const { data } = await client.get("/v2/storage/search/tables", { query }, {
+			signal,
+			queryArrayFormat: "comma"
+		});
+		return data;
+	};
+	return {
+		globalSearch,
+		searchTables
+	};
+};
+//#endregion
+//#region src/clients/storage/snapshots/snapshots.ts
+const createSnapshots = (client) => {
+	/**
+	* Creates a snapshot of a table in the given branch. Async — returns a job.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/POST/v2/storage/branch/{branchId}/tables/{id}/snapshots
+	*/
+	const createSnapshotAsync = async ({ branchId, tableId, ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/tables/{id}/snapshots", {
+			path: {
+				branchId,
+				id: tableId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Reads a single snapshot. Not branch-scoped — a snapshot id is unique across branches.
+	*
+	* The swagger stubs the operation (a single `default` response with no body), so the shape is
+	* asserted in; it is the same `Snapshot` the table listing returns.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/GET/v2/storage/snapshots/{snapshotId}
+	*/
+	const getSnapshot = async (snapshotId, signal) => {
+		const { data } = await client.get("/v2/storage/snapshots/{snapshotId}", { path: { snapshotId } }, { signal });
+		return data;
+	};
+	/**
+	* Deletes a snapshot, returning the storage job that performs it (`null` when the backend answers
+	* with no content). The endpoint is not branch-scoped — a snapshot id is unique across branches, so
+	* there is no `/branch/{branchId}/snapshots/{snapshotId}` variant.
+	*
+	* The swagger documents a single bodyless `default` response, so the job is asserted in.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/DELETE/v2/storage/snapshots/{snapshotId}
+	*/
+	const deleteSnapshotAsync = async (snapshotId, signal) => {
+		const { data } = await client.delete("/v2/storage/snapshots/{snapshotId}", { path: { snapshotId } }, { signal });
+		return data;
+	};
+	/**
+	* Lists the snapshots of a table in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/GET/v2/storage/branch/{branchId}/tables/{id}/snapshots
+	*/
+	const getTableSnapshots = async ({ branchId, tableId, ...query }, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/tables/{id}/snapshots", {
+			path: {
+				branchId,
+				id: tableId
+			},
+			query
+		}, { signal });
+		return data;
+	};
+	return {
+		createSnapshotAsync,
+		deleteSnapshotAsync,
+		getSnapshot,
+		getTableSnapshots
+	};
+};
+//#endregion
+//#region src/clients/storage/stats/stats.ts
+/**
+* `GET /v2/storage/stats` (`StatsListAction`) declares a single contentless `default` response, so the
+* generated return type is the response envelope (`{ headers, content?: never }`) rather than a
+* payload — hence the assertion to the hand-authored `RunIdStats`. The `runId` query is spec-derived.
+*/
+const createStats = (client) => {
+	/**
+	* Returns import/export table stats for a job run, identified by its runId.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/GET/v2/storage/stats
+	*/
+	const getRunIdStats = async (runId, signal) => {
+		const { data } = await client.get("/v2/storage/stats", { query: { runId } }, { signal });
+		return data;
+	};
+	return { getRunIdStats };
+};
+//#endregion
+//#region src/clients/storage/tables/tables.ts
+const createTables = (openApiClient, client) => {
+	/**
+	* Returns every table in the given branch. Filter client-side by
+	* `table.bucket?.id` (requires `include: ['buckets']`) or by the
+	* `{bucketId}.` prefix in `table.id` (IDs use `{bucketId}.{tableName}`,
+	* e.g. `in.c-main.users`).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/GET/v2/storage/branch/{branchId}/tables
+	*/
+	const getTables = async ({ branchId, include = [], ...query }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/tables", {
+			path: { branchId },
+			query: {
+				include,
+				...query
+			}
+		}, {
+			signal,
+			queryArrayFormat: "comma"
+		});
+		return data;
+	};
+	/**
+	* Returns a table from the given branch. A dev branch only contains the tables created or pulled
+	* into it, so a production table must be read with the default branch id.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/GET/v2/storage/branch/{branchId}/tables/{id}
+	*/
+	const getTable = async ({ branchId, id }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/tables/{id}", { path: {
+			branchId,
+			id
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Deletes a table (synchronous). `force` also drops the aliases and links pointing at it, which
+	* the API otherwise refuses.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/DELETE/v2/storage/branch/{branchId}/tables/{id}
+	*/
+	const deleteTable = async ({ branchId, id, ...query }, signal) => {
+		await openApiClient.delete("/v2/storage/branch/{branchId}/tables/{id}", {
+			path: {
+				branchId,
+				id
+			},
+			query
+		}, { signal });
+	};
+	const deleteTables = async ({ branchId, ids, force }) => {
+		await concurrent({
+			items: ids,
+			process: (id) => deleteTable({
+				branchId,
+				id,
+				force
+			})
+		});
+	};
+	const deleteTableRows = async ({ branchId, id, ...query }, signal) => {
+		const { data } = await openApiClient.delete("/v2/storage/branch/{branchId}/tables/{id}/rows", {
+			path: {
+				branchId,
+				id
+			},
+			query
+		}, { signal });
+		return data;
+	};
+	/**
+	* Returns the first rows of a table in the given branch.
+	*
+	* The swagger declares `query?: never` here, so it cannot express `limit` / `whereFilters` /
+	* `orderBy` / `fulltextSearch`, all of which the endpoint accepts — hence the hand-authored
+	* `GetDataPreviewQuery` and the asserted query.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/GET/v2/storage/branch/{branchId}/tables/{tableId}/data-preview
+	*/
+	const getDataPreview = async ({ branchId, tableId, ...query }, signal) => {
+		const { data } = await openApiClient.get("/v2/storage/branch/{branchId}/tables/{tableId}/data-preview", {
+			path: {
+				branchId,
+				tableId
+			},
+			query: {
+				format: "json",
+				...query
+			}
+		}, { signal });
+		return data;
+	};
+	/**
+	* Exports a table to a file. Async — returns a job.
+	*
+	* Unbranched, though the document also declares
+	* `/v2/storage/branch/{branchId}/tables/{tableId}/export-async`: export was outside the scope of
+	* the table migration (UT-4785), so switching it would change behaviour for a flow that migration
+	* did not touch. It is the one remaining branch-capable method here that does not take a
+	* `branchId`, and moving it is a clean follow-up.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/POST/v2/storage/tables/{tableId}/export-async
+	*/
+	const exportAsync = async ({ tableId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/tables/{tableId}/export-async", {
+			path: { tableId },
+			body
+		}, { signal });
+		return data;
+	};
+	const createTableAsync = async ({ branchId, id, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{id}/tables-async", {
+			path: {
+				branchId,
+				id
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Creates a typed table from an explicit column definition (no data) in the given bucket.
+	* The endpoint is async: it returns a `tableDefinitionCreate` storage job the caller can poll.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/buckets/POST/v2/storage/branch/{branchId}/buckets/{bucketId}/tables-definition
+	*/
+	const createTableDefinitionAsync = async ({ branchId, bucketId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/buckets/{bucketId}/tables-definition", {
+			path: {
+				branchId,
+				bucketId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	const importAsync = async ({ branchId, id, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/tables/{id}/import-async", {
+			path: {
+				branchId,
+				id
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Updates a table's definition in place — `displayName`, `description`,
+	* `isDescriptionSystemManaged`, and per-column
+	* `length`/`nullable`/`default`/`description`. The endpoint is async: it
+	* returns a `tableDefinitionUpdate` storage job that the caller can poll.
+	*
+	* Send only the fields being changed; at least one is required. Description
+	* patches apply to non-typed tables too, so a description-only edit needs
+	* neither `displayName` nor `columns`.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/PUT/v2/storage/branch/{branchId}/tables/{tableId}/definition
+	*/
+	const updateTableDefinition = async ({ branchId, tableId, ...body }, signal) => {
+		const { data } = await openApiClient.put("/v2/storage/branch/{branchId}/tables/{tableId}/definition", {
+			path: {
+				branchId,
+				tableId
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Updates a table's display name (synchronous). For typed-table column/definition changes use
+	* `updateTableDefinition` instead.
+	*
+	* On the generic client and unbranched, unlike its siblings — but only because of where the
+	* endpoint lives, not because of what it supports. It is still `Storage_TablesController::putAction`
+	* in connection's legacy Zend app, and the Storage document is generated from the `#[OA\...]`
+	* attributes on the migrated Symfony controllers, so no annotation fix closes this gap; the
+	* controller has to move first. The action does take a `DevBranch`, and `put` is in the
+	* branch-implemented route list, so `/branch/{branchId}/tables/{id}` works — there is simply no
+	* `paths` entry to derive it from, and the branch prefix is left to the caller's middleware.
+	*
+	* The synchronous form this calls is deprecated backend-side (`DEPRECATION_SYNC_UPDATE_TABLE` is
+	* logged per request); `?async=true` returns a `tableUpdate` job instead. Switching means polling,
+	* so it belongs with the caller that renames tables, not here.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables
+	*/
+	const updateTable = async ({ tableId, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/tables/{id}", {
+			path: { id: tableId },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Pulls a table from the default branch into the given dev branch.
+	*
+	* The path is branch-scoped: the unbranched `/v2/storage/tables/{id}/pull` this used to call is
+	* absent from the Storage document and 404s for every table (the live nightly caught it), because
+	* nothing in it says which branch to pull into.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables
+	*/
+	const pullTableAsync = async ({ branchId, id }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/tables/{id}/pull", { path: {
+			branchId,
+			id
+		} }, { signal });
+		return data;
+	};
+	/**
+	* Creates an alias table in the given bucket. Usually returns the created alias `Table`
+	* synchronously; for BigQuery VIEW-persisted aliases the API instead returns an `aliasCreate`
+	* storage job, so the response is typed as a union — narrow on `operationName` before use.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables
+	*/
+	const createAliasTable = async ({ bucketId, ...body }, signal) => {
+		const { data } = await client.post("/v2/storage/buckets/{bucketId}/table-aliases", {
+			path: { bucketId },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Sets (replaces) the filter of an alias table (synchronous).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables
+	*/
+	const setAliasTableFilter = async ({ tableId, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/tables/{tableId}/alias-filter", {
+			path: { tableId },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Removes the filter of an alias table (synchronous).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables
+	*/
+	const removeAliasTableFilter = async (tableId, signal) => {
+		await openApiClient.delete("/v2/storage/tables/{tableId}/alias-filter", { path: { tableId } }, { signal });
+	};
+	/**
+	* Adds or updates metadata on a table in the given branch, and on its columns when the payload
+	* names any — which is why the response carries `columnsMetadata` alongside `metadata`.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/POST/v2/storage/branch/{branchId}/tables/{id}/metadata
+	*/
+	const saveTableMetadata = async ({ branchId, id, ...body }, signal) => {
+		const { data } = await openApiClient.post("/v2/storage/branch/{branchId}/tables/{id}/metadata", {
+			path: {
+				branchId,
+				id
+			},
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a single metadata entry from a table in the given branch.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tables/DELETE/v2/storage/branch/{branchId}/tables/{id}/metadata/{metadataId}
+	*/
+	const deleteTableMetadata = async ({ branchId, id, metadataId }, signal) => {
+		await openApiClient.delete("/v2/storage/branch/{branchId}/tables/{id}/metadata/{metadataId}", { path: {
+			branchId,
+			id,
+			metadataId
+		} }, { signal });
+	};
+	return {
+		getTables,
+		getTable,
+		getDataPreview,
+		deleteTable,
+		deleteTables,
+		deleteTableRows,
+		exportAsync,
+		createTableAsync,
+		createTableDefinitionAsync,
+		importAsync,
+		updateTableDefinition,
+		updateTable,
+		pullTableAsync,
+		createAliasTable,
+		setAliasTableFilter,
+		removeAliasTableFilter,
+		saveTableMetadata,
+		deleteTableMetadata
+	};
+};
+//#endregion
+//#region src/clients/storage/tokens/tokens.ts
+/**
+* The `as` casts below work around a broken generated schema, not our own types:
+*
+* - id path params typed `number`; every id the API returns is a `string`
+* - `UpdateTokenRequest` / `ShareTokenRequest` modelled as empty objects
+* - update `200` declares no body, but returns the updated token
+* - create body marks fields required that the API defaults
+*
+* `./types` holds the real contracts. Drop each cast as the backend fixes the schema.
+*/
+const createTokens = (client) => {
+	const verify = async (signal) => {
+		const { data } = await client.get("/v2/storage/tokens/verify", {}, { signal });
+		return data;
+	};
+	const refresh = async (id, signal) => {
+		const { data } = await client.post("/v2/storage/tokens/{id}/refresh", { path: { id } }, { signal });
+		return data;
+	};
+	/**
+	* Lists storage tokens accessible by the current token.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/GET/v2/storage/tokens
+	*/
+	const getTokens = async (signal) => {
+		const { data } = await client.get("/v2/storage/tokens", {}, { signal });
+		return data;
+	};
+	/**
+	* Creates a new storage token. The response includes the freshly issued `token` secret.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/POST/v2/storage/tokens
+	*/
+	const createToken = async (body, signal) => {
+		const { data } = await client.post("/v2/storage/tokens", { body }, { signal });
+		return data;
+	};
+	/**
+	* Updates an existing storage token (description, permissions, expiration, …).
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/PUT/v2/storage/tokens/{id}
+	*/
+	const updateToken = async ({ id, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/tokens/{id}", {
+			path: { id },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a storage token.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/DELETE/v2/storage/tokens/{id}
+	*/
+	const deleteToken = async (id, signal) => {
+		await client.delete("/v2/storage/tokens/{id}", { path: { id } }, { signal });
+	};
+	/**
+	* Shares a storage token with another user by email.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/POST/v2/storage/tokens/{id}/share
+	*/
+	const shareToken = async ({ id, ...body }, signal) => {
+		await client.post("/v2/storage/tokens/{id}/share", {
+			path: { id },
+			body
+		}, { signal });
+	};
+	/**
+	* Event feed of a single token — what that token did, not what happened to it.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/tokens/GET/v2/storage/tokens/{id}/events
+	*/
+	const getTokenEvents = async ({ id, ...query }, signal) => {
+		const { data } = await client.get("/v2/storage/tokens/{id}/events", {
+			path: { id },
+			query
+		}, { signal });
+		return data;
+	};
+	return {
+		verify,
+		refresh,
+		getTokens,
+		createToken,
+		updateToken,
+		deleteToken,
+		shareToken,
+		getTokenEvents
+	};
+};
+//#endregion
+//#region src/clients/storage/triggers/triggers.ts
+const createTriggers = (client) => {
+	/**
+	* Lists triggers in the project, optionally filtered by component / configuration.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/triggers/GET/v2/storage/triggers
+	*/
+	const getTriggers = async (query, signal) => {
+		const { data } = await client.get("/v2/storage/triggers", { query }, { signal });
+		return data;
+	};
+	/**
+	* Creates a new trigger for a component configuration.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/triggers/POST/v2/storage/triggers
+	*/
+	const createTrigger = async (body, signal) => {
+		const { data } = await client.post("/v2/storage/triggers", { body }, { signal });
+		return data;
+	};
+	/**
+	* Updates an existing trigger, patching only the fields the input carries.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/triggers/PUT/v2/storage/triggers/{triggerId}
+	*/
+	const updateTrigger = async ({ triggerId, ...body }, signal) => {
+		const { data } = await client.put("/v2/storage/triggers/{triggerId}", {
+			path: { triggerId },
+			body
+		}, { signal });
+		return data;
+	};
+	/**
+	* Deletes a trigger.
+	*
+	* @link https://api.keboola.com/?service=storage#storage/tag/triggers/DELETE/v2/storage/triggers/{triggerId}
+	*/
+	const deleteTrigger = async (triggerId, signal) => {
+		await client.delete("/v2/storage/triggers/{triggerId}", { path: { triggerId } }, { signal });
+	};
+	return {
+		getTriggers,
+		createTrigger,
+		updateTrigger,
+		deleteTrigger
+	};
+};
+//#endregion
+//#region src/clients/storage/workspaces/workspaces.ts
+/**
+* Paths, queries and bodies come from the spec; only the returns are asserted in.
+*
+* - `WorkspaceDetailResponse` describes a narrower connection than callers get, so `Workspace` is
+*   hand-authored (see `./types`) — that covers the list, detail and public-key returns.
+* - The password, SSO and delete operations answer a contentless `default`.
+* - `JobResponse` is a flat shape with `status: string`, while `Job<T>` is a discriminated union over
+*   `status` carrying typed `results`.
+*
+* `workspaceId` is a `number` in every input; the operations whose spec segment is a `string` take
+* `String(workspaceId)` here rather than pushing the spec's inconsistency onto callers.
+*/
+const createWorkspaces = (client) => {
+	const getWorkspaces = async (path, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/workspaces", { path }, { signal });
+		return data;
+	};
+	const getWorkspace = async (path, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/workspaces/{workspaceId}", { path }, { signal });
+		return data;
+	};
+	const deleteWorkspace = async ({ branchId, workspaceId }) => {
+		await client.delete("/v2/storage/branch/{branchId}/workspaces/{workspaceId}", { path: {
+			branchId,
+			workspaceId: String(workspaceId)
+		} });
+	};
+	const deleteWorkspaces = async ({ workspaceIds, branchId }) => {
+		await concurrent({
+			items: workspaceIds,
+			process: async (workspaceId) => deleteWorkspace({
+				branchId,
+				workspaceId
+			}),
+			concurrency: 5
+		});
+	};
+	const deleteWorkspaceJob = async ({ branchId, workspaceId }) => {
+		const { data } = await client.delete("/v2/storage/branch/{branchId}/workspaces/{workspaceId}", {
+			path: {
+				branchId,
+				workspaceId: String(workspaceId)
+			},
+			query: { async: true }
+		});
+		return data;
+	};
+	const resetWorkspacePassword = async ({ branchId, workspaceId }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/password", { path: {
+			branchId,
+			workspaceId: String(workspaceId)
+		} });
+		return data;
+	};
+	const getWorkspaceSaml2Login = async (path, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/saml2-login", { path }, { signal });
+		return data;
+	};
+	/**
+	* Set the public key for the workspace user, or migrate workspace from password to key auth.
+	* Supported only on Snowflake.
+	* When called, either a new key is created, or the older one is replaced.
+	*/
+	const setWorkspacePublicKey = async ({ branchId, workspaceId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/public-key", {
+			path: {
+				branchId,
+				workspaceId: String(workspaceId)
+			},
+			body
+		});
+		return data;
+	};
+	const getWorkspaceObjects = async (path, signal) => {
+		const { data } = await client.get("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects", { path }, { signal });
+		return data;
+	};
+	const deleteWorkspaceObjectsAsync = async ({ branchId, workspaceId, ...body }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete", {
+			path: {
+				branchId,
+				workspaceId
+			},
+			body
+		});
+		return data;
+	};
+	const unloadWorkspace = async ({ branchId, workspaceId, ...query }) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/unload", {
+			path: {
+				branchId,
+				workspaceId
+			},
+			query
+		});
+		return data;
+	};
+	/**
+	* Preview the resolved load types for a component-style input-mapping config without a workspace.
+	* Returns the preferred load type plus the possible load types per table for the resolved backend,
+	* without creating a job. The backend is resolved per item from the item `backend` field, then the
+	* `backend` argument, then the project default.
+	*/
+	const inputMappingLoadPreview = async ({ branchId, body, backend }, signal) => {
+		const { data } = await client.post("/v2/storage/branch/{branchId}/input-mapping-load/preview", {
+			path: { branchId },
+			query: backend ? { backend } : void 0,
+			body
+		}, { signal });
+		return data;
+	};
+	return {
+		getWorkspace,
+		getWorkspaces,
+		deleteWorkspace,
+		resetWorkspacePassword,
+		deleteWorkspaces,
+		deleteWorkspaceJob,
+		setWorkspacePublicKey,
+		getWorkspaceSaml2Login,
+		getWorkspaceObjects,
+		deleteWorkspaceObjectsAsync,
+		unloadWorkspace,
+		inputMappingLoadPreview
+	};
+};
+//#endregion
+//#region src/clients/storage/storageClient.ts
+const createStorageClient = ({ baseUrl, auth, middlewares = [], onRefreshToken }) => {
+	const headers = createAuthHeaders(auth);
+	const allMiddlewares = onRefreshToken && auth.type === "sapi-token" ? [...middlewares, createRefreshTokenMiddlware({
+		accessToken: auth.token,
+		onRefresh: onRefreshToken
+	})] : middlewares;
+	const genericClient = createGenericFetchClient({
+		baseUrl,
+		middlewares: allMiddlewares,
+		headers,
+		validateStatus: validateConnectionStatus
+	});
+	const client = createOpenapiFetchClient({
+		baseUrl,
+		middlewares: allMiddlewares,
+		headers,
+		validateStatus: validateConnectionStatus
+	});
+	const getStackInfo = async (query, signal) => {
+		const { data } = await client.get("/v2/storage", { query }, { signal });
+		return data;
+	};
+	const healthCheck = async (signal) => {
+		const { data } = await genericClient.get("/health-check", {}, { signal });
+		return data;
+	};
+	const jobs = createJobs(client);
+	const poller = createJobPoller({ getJob: jobs.getJob });
+	return {
+		poller,
+		healthCheck,
+		getStackInfo,
+		jobs,
+		buckets: createBuckets(client, genericClient),
+		bucketSharing: createBucketSharing(client),
+		bucketListings: createBucketListings(client),
+		bucketExternal: createBucketExternal(client),
+		tables: createTables(client, genericClient),
+		columns: createColumns(client),
+		snapshots: createSnapshots(client),
+		branches: createBranches(client, poller),
+		mergeRequests: createMergeRequests(client),
+		events: createEvents(client),
+		files: createFiles(client),
+		workspaces: createWorkspaces(client),
+		tokens: createTokens(client),
+		triggers: createTriggers(client),
+		search: createSearch(client),
+		stats: createStats(client),
+		components: createComponents(client),
+		configurations: createConfigurations(client),
+		configurationRows: createConfigurationRows(client),
+		configurationWorkspaces: createConfigurationWorkspaces(client),
+		configurationMetadata: createConfigurationMetadata(client),
+		configurationVersions: createConfigurationVersions(client)
+	};
+};
+//#endregion
+export { series as a, ServiceUnavailableError as i, fromBackendSubscribers as n, toBackendSubscribers as r, createStorageClient as t };
+
+//# sourceMappingURL=storage-CQxu0EY3.js.map