@revisium/client 0.1.0-alpha.1 → 0.2.0

package/dist/index.mjs

@@ -1,19 +1,2279 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/generated/core/bodySerializer.gen.ts
+const serializeFormDataPair = (data, key, value) => {
+	if (typeof value === "string" || value instanceof Blob) data.append(key, value);
+	else if (value instanceof Date) data.append(key, value.toISOString());
+	else data.append(key, JSON.stringify(value));
+};
+const formDataBodySerializer = { bodySerializer: (body) => {
+	const data = new FormData();
+	Object.entries(body).forEach(([key, value]) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) value.forEach((v) => serializeFormDataPair(data, key, v));
+		else serializeFormDataPair(data, key, value);
+	});
+	return data;
+} };
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+
+//#endregion
+//#region src/generated/core/params.gen.ts
+const extraPrefixes = Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.ts
+const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+};
+
+//#endregion
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+//#endregion
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+
+//#endregion
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+
+//#endregion
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+const setAuthParams = async ({ security, ...options }) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+
+//#endregion
+//#region src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		return {
+			opts,
+			url: buildUrl(opts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: getValidRequestBody(opts)
+		};
+		let request = new Request(url, requestInit);
+		for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+		const _fetch = opts.fetch;
+		let response;
+		try {
+			response = await _fetch(request);
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, void 0, request, opts);
+			finalError = finalError || {};
+			if (opts.throwOnError) throw finalError;
+			return opts.responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response: void 0
+			};
+		}
+		for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+		const result = {
+			request,
+			response
+		};
+		if (response.ok) {
+			const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+			if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+				let emptyData;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "text":
+						emptyData = await response[parseAs]();
+						break;
+					case "formData":
+						emptyData = new FormData();
+						break;
+					case "stream":
+						emptyData = response.body;
+						break;
+					default:
+						emptyData = {};
+						break;
+				}
+				return opts.responseStyle === "data" ? emptyData : {
+					data: emptyData,
+					...result
+				};
+			}
+			let data;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "json": {
+					const text = await response.text();
+					data = text ? JSON.parse(text) : {};
+					break;
+				}
+				case "stream": return opts.responseStyle === "data" ? response.body : {
+					data: response.body,
+					...result
+				};
+			}
+			if (parseAs === "json") {
+				if (opts.responseValidator) await opts.responseValidator(data);
+				if (opts.responseTransformer) data = await opts.responseTransformer(data);
+			}
+			return opts.responseStyle === "data" ? data : {
+				data,
+				...result
+			};
+		}
+		const textError = await response.text();
+		let jsonError;
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request, opts);
+		finalError = finalError || {};
+		if (opts.throwOnError) throw finalError;
+		return opts.responseStyle === "data" ? void 0 : {
+			error: finalError,
+			...result
+		};
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			headers: opts.headers,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	return {
+		buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig());
+
+//#endregion
+//#region src/generated/sdk.gen.ts
+var sdk_gen_exports = /* @__PURE__ */ __exportAll({
+	addUserToOrganization: () => addUserToOrganization,
+	addUserToProject: () => addUserToProject,
+	applyMigrations: () => applyMigrations,
+	branch: () => branch,
+	branchTouched: () => branchTouched,
+	branches: () => branches,
+	childBranches: () => childBranches,
+	childRevision: () => childRevision,
+	createBranch: () => createBranch,
+	createEndpoint: () => createEndpoint,
+	createProject: () => createProject,
+	createRevision: () => createRevision,
+	createRow: () => createRow$1,
+	createRows: () => createRows$1,
+	createTable: () => createTable$1,
+	createUser: () => createUser,
+	deleteBranch: () => deleteBranch,
+	deleteEndpoint: () => deleteEndpoint,
+	deleteProject: () => deleteProject,
+	deleteRow: () => deleteRow$1,
+	deleteRows: () => deleteRows$1,
+	deleteTable: () => deleteTable$1,
+	draftRevision: () => draftRevision,
+	endpointRelatives: () => endpointRelatives,
+	endpoints: () => endpoints,
+	getConfiguration: () => getConfiguration,
+	headRevision: () => headRevision,
+	liveness: () => liveness,
+	login: () => login,
+	me: () => me,
+	migrations: () => migrations,
+	parentBranch: () => parentBranch,
+	parentRevision: () => parentRevision,
+	patchRow: () => patchRow$1,
+	patchRows: () => patchRows,
+	project: () => project,
+	projects: () => projects,
+	readiness: () => readiness,
+	removeUserFromOrganization: () => removeUserFromOrganization,
+	removeUserFromProject: () => removeUserFromProject,
+	renameRow: () => renameRow$1,
+	renameTable: () => renameTable$1,
+	revertChanges: () => revertChanges$1,
+	revision: () => revision,
+	revisionChanges: () => revisionChanges,
+	revisions: () => revisions,
+	rootBranch: () => rootBranch,
+	row: () => row,
+	rowChanges: () => rowChanges,
+	rowCountForeignKeysBy: () => rowCountForeignKeysBy,
+	rowCountForeignKeysTo: () => rowCountForeignKeysTo,
+	rowForeignKeysBy: () => rowForeignKeysBy,
+	rowForeignKeysTo: () => rowForeignKeysTo,
+	rows: () => rows,
+	startRevision: () => startRevision,
+	table: () => table,
+	tableChanges: () => tableChanges,
+	tableCountForeignKeysBy: () => tableCountForeignKeysBy,
+	tableCountForeignKeysTo: () => tableCountForeignKeysTo,
+	tableCountRows: () => tableCountRows,
+	tableForeignKeysBy: () => tableForeignKeysBy,
+	tableForeignKeysTo: () => tableForeignKeysTo,
+	tableSchema: () => tableSchema,
+	tables: () => tables,
+	updatePassword: () => updatePassword,
+	updateProject: () => updateProject,
+	updateRow: () => updateRow$1,
+	updateRows: () => updateRows$1,
+	updateTable: () => updateTable$1,
+	uploadFile: () => uploadFile,
+	usersOrganization: () => usersOrganization,
+	usersProject: () => usersProject
+});
+/**
+* Authenticate and get access token
+*/
+const login = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/auth/login",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create a new user (admin only)
+*/
+const createUser = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/auth/user",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update your password
+*/
+const updatePassword = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/auth/password",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get current authenticated user
+*/
+const me = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/user/me",
+	...options
+});
+/**
+* List projects in organization
+*/
+const projects = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects",
+	...options
+});
+/**
+* Create a new project
+*/
+const createProject = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Remove a user from the organization
+*/
+const removeUserFromOrganization = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/users",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List users in organization
+*/
+const usersOrganization = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/users",
+	...options
+});
+/**
+* Add a user to the organization
+*/
+const addUserToOrganization = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/users",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a project
+*/
+const deleteProject = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}",
+	...options
+});
+/**
+* Get project by name
+*/
+const project = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}",
+	...options
+});
+/**
+* Update project settings
+*/
+const updateProject = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get root branch of the project
+*/
+const rootBranch = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/root-branch",
+	...options
+});
+/**
+* List all branches in the project
+*/
+const branches = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches",
+	...options
+});
+/**
+* List users with access to the project
+*/
+const usersProject = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/users",
+	...options
+});
+/**
+* Add a user to the project
+*/
+const addUserToProject = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/users",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Remove a user from the project
+*/
+const removeUserFromProject = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/users/{userId}",
+	...options
+});
+/**
+* Delete a non-root branch
+*/
+const deleteBranch = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}",
+	...options
+});
+/**
+* Get branch by name
+*/
+const branch = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}",
+	...options
+});
+/**
+* Check if branch has uncommitted changes
+*/
+const branchTouched = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/touched",
+	...options
+});
+/**
+* Get parent branch (if created from another branch)
+*/
+const parentBranch = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/parent-branch",
+	...options
+});
+/**
+* Get the first revision of the branch
+*/
+const startRevision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/start-revision",
+	...options
+});
+/**
+* Get the latest committed revision
+*/
+const headRevision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/head-revision",
+	...options
+});
+/**
+* Get the draft (working) revision for modifications
+*/
+const draftRevision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/draft-revision",
+	...options
+});
+/**
+* List all revisions in the branch
+*/
+const revisions = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/revisions",
+	...options
+});
+/**
+* Commit changes and create a new revision
+*/
+const createRevision = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/create-revision",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Discard all uncommitted changes
+*/
+const revertChanges$1 = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/organization/{organizationId}/projects/{projectName}/branches/{branchName}/revert-changes",
+	...options
+});
+/**
+* Get revision by ID
+*/
+const revision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}",
+	...options
+});
+/**
+* Get parent revision
+*/
+const parentRevision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/parent-revision",
+	...options
+});
+/**
+* Get child revision
+*/
+const childRevision = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/child-revision",
+	...options
+});
+/**
+* List branches created from this revision
+*/
+const childBranches = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/child-branches",
+	...options
+});
+/**
+* Create a new branch from this revision
+*/
+const createBranch = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/child-branches",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List tables in revision
+*/
+const tables = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables",
+	...options
+});
+/**
+* Create a new table
+*/
+const createTable$1 = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List API endpoints for this revision
+*/
+const endpoints = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/endpoints",
+	...options
+});
+/**
+* Create an API endpoint for this revision
+*/
+const createEndpoint = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/endpoints",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get schema migrations from this revision
+*/
+const migrations = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/migrations",
+	...options
+});
+/**
+* Get revision changes summary
+*/
+const revisionChanges = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/changes",
+	...options
+});
+/**
+* Get paginated table changes for a revision
+*/
+const tableChanges = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/table-changes",
+	...options
+});
+/**
+* Get paginated row changes for a revision
+*/
+const rowChanges = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/row-changes",
+	...options
+});
+/**
+* Apply schema migrations to this revision
+*/
+const applyMigrations = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/apply-migrations",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a table
+*/
+const deleteTable$1 = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}",
+	...options
+});
+/**
+* Get table by ID
+*/
+const table = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}",
+	...options
+});
+/**
+* Update table schema using JSON Patch
+*/
+const updateTable$1 = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get row count in table
+*/
+const tableCountRows = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/count-rows",
+	...options
+});
+/**
+* Delete multiple rows
+*/
+const deleteRows$1 = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List rows in table with filtering and sorting
+*/
+const rows = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create a new row
+*/
+const createRow$1 = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/create-row",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create multiple rows
+*/
+const createRows$1 = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/create-rows",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Replace data for multiple rows
+*/
+const updateRows$1 = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/update-rows",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Patch multiple rows using JSON Patch
+*/
+const patchRows = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/patch-rows",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get table JSON Schema
+*/
+const tableSchema = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/schema",
+	...options
+});
+/**
+* Count tables that reference this table
+*/
+const tableCountForeignKeysBy = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/count-foreign-keys-by",
+	...options
+});
+/**
+* List tables that reference this table
+*/
+const tableForeignKeysBy = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/foreign-keys-by",
+	...options
+});
+/**
+* Count tables this table references
+*/
+const tableCountForeignKeysTo = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/count-foreign-keys-to",
+	...options
+});
+/**
+* List tables this table references
+*/
+const tableForeignKeysTo = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/foreign-keys-to",
+	...options
+});
+/**
+* Rename a table
+*/
+const renameTable$1 = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rename",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a row
+*/
+const deleteRow$1 = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}",
+	...options
+});
+/**
+* Get row by ID
+*/
+const row = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}",
+	...options
+});
+/**
+* Patch row data using JSON Patch
+*/
+const patchRow$1 = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Replace row data
+*/
+const updateRow$1 = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Count rows that reference this row
+*/
+const rowCountForeignKeysBy = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/count-foreign-keys-by",
+	...options
+});
+/**
+* List rows that reference this row
+*/
+const rowForeignKeysBy = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/foreign-keys-by",
+	...options
+});
+/**
+* Count rows this row references
+*/
+const rowCountForeignKeysTo = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/count-foreign-keys-to",
+	...options
+});
+/**
+* List rows this row references
+*/
+const rowForeignKeysTo = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/foreign-keys-to",
+	...options
+});
+/**
+* Rename a row
+*/
+const renameRow$1 = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/rename",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Upload a file to a row field
+*/
+const uploadFile = (options) => (options.client ?? client).post({
+	...formDataBodySerializer,
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/revision/{revisionId}/tables/{tableId}/rows/{rowId}/upload/{fileId}",
+	...options,
+	headers: {
+		"Content-Type": null,
+		...options.headers
+	}
+});
+/**
+* Get endpoint with all related entities
+*/
+const endpointRelatives = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/endpoints/{endpointId}/relatives",
+	...options
+});
+/**
+* Delete an endpoint
+*/
+const deleteEndpoint = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/api/endpoints/{endpointId}",
+	...options
+});
+/**
+* Get system configuration
+*/
+const getConfiguration = (options) => (options?.client ?? client).get({
+	url: "/api/configuration",
+	...options
+});
+const readiness = (options) => (options?.client ?? client).get({
+	url: "/health/readiness",
+	...options
+});
+const liveness = (options) => (options?.client ?? client).get({
+	url: "/health/liveness",
+	...options
+});
+
+//#endregion
+//#region src/data-operations.ts
+function unwrap(result) {
+	if (result.error) {
+		const err = result.error;
+		throw new Error(err.message ?? `API error: ${JSON.stringify(result.error)}`);
+	}
+	return result.data;
+}
+function assertDraft(ctx) {
+	assertContext(ctx);
+	if (!ctx.isDraft) throw new Error("Mutations are only allowed in draft revision. Use setContext({ revision: \"draft\" }).");
+}
+function assertContext(ctx) {
+	if (!ctx.branch.organizationId) throw new Error("Context not set. Call setContext() first.");
+}
+async function getTables(ctx, options) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await tables({
+		client: ctx.client,
+		path: { revisionId },
+		query: {
+			first: options?.first ?? 100,
+			after: options?.after
+		}
+	}));
+}
+async function getTable(ctx, tableId) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await table({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		}
+	}));
+}
+async function getTableSchema(ctx, tableId) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await tableSchema({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		}
+	}));
+}
+async function getRows(ctx, tableId, options) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await rows({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: options ?? { first: 100 }
+	}));
+}
+async function getRow(ctx, tableId, rowId) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await row({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId,
+			rowId
+		}
+	}));
+}
+async function getChanges(ctx) {
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await revisionChanges({
+		client: ctx.client,
+		path: { revisionId }
+	}));
+}
+async function createTable(ctx, tableId, schema) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await createTable$1({
+		client: ctx.client,
+		path: { revisionId },
+		body: {
+			tableId,
+			schema
+		}
+	}));
+}
+async function updateTable(ctx, tableId, patches) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await updateTable$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: { patches }
+	}));
+}
+async function deleteTable(ctx, tableId) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	unwrap(await deleteTable$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		}
+	}));
+}
+async function renameTable(ctx, tableId, nextTableId) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await renameTable$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: { nextTableId }
+	}));
+}
+async function createRow(ctx, tableId, rowId, data) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await createRow$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: {
+			rowId,
+			data
+		}
+	}));
+}
+async function createRows(ctx, tableId, rows) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await createRows$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: { rows: rows.map((r) => ({
+			rowId: r.rowId,
+			data: r.data
+		})) }
+	}));
+}
+async function updateRow(ctx, tableId, rowId, data) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await updateRow$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId,
+			rowId
+		},
+		body: { data }
+	}));
+}
+async function updateRows(ctx, tableId, rows) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await updateRows$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: { rows: rows.map((r) => ({
+			rowId: r.rowId,
+			data: r.data
+		})) }
+	}));
+}
+async function patchRow(ctx, tableId, rowId, patches) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await patchRow$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId,
+			rowId
+		},
+		body: { patches }
+	}));
+}
+async function deleteRow(ctx, tableId, rowId) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	unwrap(await deleteRow$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId,
+			rowId
+		}
+	}));
+}
+async function deleteRows(ctx, tableId, rowIds) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	unwrap(await deleteRows$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId
+		},
+		body: { rowIds }
+	}));
+}
+async function renameRow(ctx, tableId, rowId, nextRowId) {
+	assertDraft(ctx);
+	const revisionId = await ctx.getRevisionId();
+	return unwrap(await renameRow$1({
+		client: ctx.client,
+		path: {
+			revisionId,
+			tableId,
+			rowId
+		},
+		body: { nextRowId }
+	}));
+}
+async function commit(ctx, comment) {
+	assertDraft(ctx);
+	return unwrap(await createRevision({
+		client: ctx.client,
+		path: {
+			organizationId: ctx.branch.organizationId,
+			projectName: ctx.branch.projectName,
+			branchName: ctx.branch.branchName
+		},
+		body: { comment }
+	}));
+}
+async function revertChanges(ctx) {
+	assertDraft(ctx);
+	unwrap(await revertChanges$1({
+		client: ctx.client,
+		path: {
+			organizationId: ctx.branch.organizationId,
+			projectName: ctx.branch.projectName,
+			branchName: ctx.branch.branchName
+		}
+	}));
+}
+async function fetchDraftRevisionId(client, branch) {
+	return unwrap(await draftRevision({
+		client,
+		path: {
+			organizationId: branch.organizationId,
+			projectName: branch.projectName,
+			branchName: branch.branchName
+		}
+	})).id;
+}
+async function fetchHeadRevisionId(client, branch) {
+	return unwrap(await headRevision({
+		client,
+		path: {
+			organizationId: branch.organizationId,
+			projectName: branch.projectName,
+			branchName: branch.branchName
+		}
+	})).id;
+}
+async function validateRevisionId(client, revisionId) {
+	unwrap(await revision({
+		client,
+		path: { revisionId }
+	}));
+}
+
+//#endregion
+//#region src/revisium-scope.ts
+var RevisiumScope = class {
+	_client;
+	_branch;
+	_revisionMode;
+	_owner;
+	_revisionId;
+	_isDraft;
+	_stale = false;
+	_disposed = false;
+	_refreshPromise = null;
+	constructor(init) {
+		this._client = init.client;
+		this._branch = init.branch;
+		this._revisionId = init.revisionId;
+		this._isDraft = init.isDraft;
+		this._revisionMode = init.revisionMode;
+		this._owner = init.owner;
+	}
+	get organizationId() {
+		return this._branch.organizationId;
+	}
+	get projectName() {
+		return this._branch.projectName;
+	}
+	get branchName() {
+		return this._branch.branchName;
+	}
+	get revisionId() {
+		return this._revisionId;
+	}
+	get isDraft() {
+		return this._isDraft;
+	}
+	get isStale() {
+		return this._stale;
+	}
+	get isDisposed() {
+		return this._disposed;
+	}
+	get client() {
+		return this._client;
+	}
+	markStale() {
+		if (this._revisionMode === "explicit") return;
+		this._stale = true;
+	}
+	async refresh() {
+		this.assertNotDisposed();
+		if (this._revisionMode === "explicit") return;
+		this._revisionId = await this.fetchRevisionId();
+		this._stale = false;
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		this._owner.unregisterScope(this);
+	}
+	assertNotDisposed() {
+		if (this._disposed) throw new Error("Scope has been disposed.");
+	}
+	get _branchKey() {
+		return `${this._branch.organizationId}/${this._branch.projectName}/${this._branch.branchName}`;
+	}
+	async fetchRevisionId() {
+		if (this._revisionMode === "draft") return fetchDraftRevisionId(this._client, this._branch);
+		return fetchHeadRevisionId(this._client, this._branch);
+	}
+	async getRevisionId() {
+		this.assertNotDisposed();
+		if (this._stale) {
+			this._refreshPromise ??= this.fetchRevisionId().then((id) => {
+				this._revisionId = id;
+				this._stale = false;
+				this._refreshPromise = null;
+				return id;
+			}, (err) => {
+				this._refreshPromise = null;
+				throw err;
+			});
+			return this._refreshPromise;
+		}
+		return this._revisionId;
+	}
+	get _scopeContext() {
+		return {
+			client: this._client,
+			branch: this._branch,
+			isDraft: this._isDraft,
+			getRevisionId: () => this.getRevisionId()
+		};
+	}
+	async getTables(options) {
+		return getTables(this._scopeContext, options);
+	}
+	async getTable(tableId) {
+		return getTable(this._scopeContext, tableId);
+	}
+	async getTableSchema(tableId) {
+		return getTableSchema(this._scopeContext, tableId);
+	}
+	async getRows(tableId, options) {
+		return getRows(this._scopeContext, tableId, options);
+	}
+	async getRow(tableId, rowId) {
+		return getRow(this._scopeContext, tableId, rowId);
+	}
+	async getChanges() {
+		return getChanges(this._scopeContext);
+	}
+	async createTable(tableId, schema) {
+		return createTable(this._scopeContext, tableId, schema);
+	}
+	async updateTable(tableId, patches) {
+		return updateTable(this._scopeContext, tableId, patches);
+	}
+	async deleteTable(tableId) {
+		return deleteTable(this._scopeContext, tableId);
+	}
+	async renameTable(tableId, nextTableId) {
+		return renameTable(this._scopeContext, tableId, nextTableId);
+	}
+	async createRow(tableId, rowId, data) {
+		return createRow(this._scopeContext, tableId, rowId, data);
+	}
+	async createRows(tableId, rows) {
+		return createRows(this._scopeContext, tableId, rows);
+	}
+	async updateRow(tableId, rowId, data) {
+		return updateRow(this._scopeContext, tableId, rowId, data);
+	}
+	async updateRows(tableId, rows) {
+		return updateRows(this._scopeContext, tableId, rows);
+	}
+	async patchRow(tableId, rowId, patches) {
+		return patchRow(this._scopeContext, tableId, rowId, patches);
+	}
+	async deleteRow(tableId, rowId) {
+		return deleteRow(this._scopeContext, tableId, rowId);
+	}
+	async deleteRows(tableId, rowIds) {
+		return deleteRows(this._scopeContext, tableId, rowIds);
+	}
+	async renameRow(tableId, rowId, nextRowId) {
+		return renameRow(this._scopeContext, tableId, rowId, nextRowId);
+	}
+	async commit(comment) {
+		this.assertNotDisposed();
+		const data = await commit(this._scopeContext, comment);
+		this._revisionId = await fetchDraftRevisionId(this._client, this._branch);
+		this._stale = false;
+		this._owner.notifyBranchChanged(this._branchKey, this);
+		return data;
+	}
+	async revertChanges() {
+		this.assertNotDisposed();
+		await revertChanges(this._scopeContext);
+		this._revisionId = await fetchDraftRevisionId(this._client, this._branch);
+		this._stale = false;
+		this._owner.notifyBranchChanged(this._branchKey, this);
+	}
+};
+
+//#endregion
 //#region src/revisium-client.ts
 var RevisiumClient = class {
+	_client;
 	_baseUrl;
-	_token = null;
+	_organizationId = null;
+	_projectName = null;
+	_branchName = null;
+	_revisionId = null;
+	_isDraft = false;
+	_isAuthenticated = false;
+	_scopes = /* @__PURE__ */ new Map();
 	constructor(options) {
 		const url = options.baseUrl;
 		this._baseUrl = url.endsWith("/") ? url.slice(0, -1) : url;
+		this._client = createClient(createConfig({ baseUrl: this._baseUrl }));
 	}
 	get baseUrl() {
 		return this._baseUrl;
 	}
+	get organizationId() {
+		return this._organizationId;
+	}
+	get projectName() {
+		return this._projectName;
+	}
+	get branchName() {
+		return this._branchName;
+	}
+	get revisionId() {
+		return this._revisionId;
+	}
+	get isDraft() {
+		return this._isDraft;
+	}
+	get client() {
+		return this._client;
+	}
 	isAuthenticated() {
-		return this._token !== null;
+		return this._isAuthenticated;
+	}
+	async login(username, password) {
+		const result = await login({
+			client: this._client,
+			body: {
+				emailOrUsername: username,
+				password
+			}
+		});
+		const data = unwrap(result);
+		this._client.setConfig({ auth: data.accessToken });
+		this._isAuthenticated = true;
+	}
+	loginWithToken(token) {
+		this._client.setConfig({ auth: token });
+		this._isAuthenticated = true;
+	}
+	async setContext(options) {
+		const { organizationId, projectName, branchName = "master", revision = "draft" } = options;
+		this._organizationId = organizationId;
+		this._projectName = projectName;
+		this._branchName = branchName;
+		const branch = {
+			organizationId,
+			projectName,
+			branchName
+		};
+		if (revision === "draft") {
+			this._revisionId = await fetchDraftRevisionId(this._client, branch);
+			this._isDraft = true;
+		} else if (revision === "head") {
+			this._revisionId = await fetchHeadRevisionId(this._client, branch);
+			this._isDraft = false;
+		} else {
+			await validateRevisionId(this._client, revision);
+			this._revisionId = revision;
+			this._isDraft = false;
+		}
+	}
+	async withContext(options) {
+		const { organizationId, projectName, branchName = "master", revision = "draft" } = options;
+		const branch = {
+			organizationId,
+			projectName,
+			branchName
+		};
+		let revisionId;
+		let isDraft;
+		let revisionMode;
+		if (revision === "draft") {
+			revisionId = await fetchDraftRevisionId(this._client, branch);
+			isDraft = true;
+			revisionMode = "draft";
+		} else if (revision === "head") {
+			revisionId = await fetchHeadRevisionId(this._client, branch);
+			isDraft = false;
+			revisionMode = "head";
+		} else {
+			await validateRevisionId(this._client, revision);
+			revisionId = revision;
+			isDraft = false;
+			revisionMode = "explicit";
+		}
+		const scope = new RevisiumScope({
+			client: this._client,
+			branch,
+			revisionId,
+			isDraft,
+			revisionMode,
+			owner: this
+		});
+		const branchKey = `${organizationId}/${projectName}/${branchName}`;
+		let scopeSet = this._scopes.get(branchKey);
+		if (!scopeSet) {
+			scopeSet = /* @__PURE__ */ new Set();
+			this._scopes.set(branchKey, scopeSet);
+		}
+		scopeSet.add(scope);
+		return scope;
+	}
+	notifyBranchChanged(branchKey, excludeScope) {
+		const scopeSet = this._scopes.get(branchKey);
+		if (!scopeSet) return;
+		for (const scope of scopeSet) if (scope !== excludeScope) scope.markStale();
+	}
+	unregisterScope(scope) {
+		for (const [key, scopeSet] of this._scopes) {
+			scopeSet.delete(scope);
+			if (scopeSet.size === 0) this._scopes.delete(key);
+		}
+	}
+	get _scopeContext() {
+		return {
+			client: this._client,
+			branch: {
+				organizationId: this._organizationId ?? "",
+				projectName: this._projectName ?? "",
+				branchName: this._branchName ?? ""
+			},
+			isDraft: this._isDraft,
+			getRevisionId: () => {
+				if (this._revisionId === null) return Promise.reject(/* @__PURE__ */ new Error("Context not set. Call setContext() first."));
+				return Promise.resolve(this._revisionId);
+			}
+		};
+	}
+	async getTables(options) {
+		return getTables(this._scopeContext, options);
+	}
+	async getTable(tableId) {
+		return getTable(this._scopeContext, tableId);
+	}
+	async getTableSchema(tableId) {
+		return getTableSchema(this._scopeContext, tableId);
+	}
+	async getRows(tableId, options) {
+		return getRows(this._scopeContext, tableId, options);
+	}
+	async getRow(tableId, rowId) {
+		return getRow(this._scopeContext, tableId, rowId);
+	}
+	async getChanges() {
+		return getChanges(this._scopeContext);
+	}
+	async createTable(tableId, schema) {
+		return createTable(this._scopeContext, tableId, schema);
+	}
+	async updateTable(tableId, patches) {
+		return updateTable(this._scopeContext, tableId, patches);
+	}
+	async deleteTable(tableId) {
+		return deleteTable(this._scopeContext, tableId);
+	}
+	async renameTable(tableId, nextTableId) {
+		return renameTable(this._scopeContext, tableId, nextTableId);
+	}
+	async createRow(tableId, rowId, data) {
+		return createRow(this._scopeContext, tableId, rowId, data);
+	}
+	async createRows(tableId, rows) {
+		return createRows(this._scopeContext, tableId, rows);
+	}
+	async updateRow(tableId, rowId, data) {
+		return updateRow(this._scopeContext, tableId, rowId, data);
+	}
+	async updateRows(tableId, rows) {
+		return updateRows(this._scopeContext, tableId, rows);
+	}
+	async patchRow(tableId, rowId, patches) {
+		return patchRow(this._scopeContext, tableId, rowId, patches);
+	}
+	async deleteRow(tableId, rowId) {
+		return deleteRow(this._scopeContext, tableId, rowId);
+	}
+	async deleteRows(tableId, rowIds) {
+		return deleteRows(this._scopeContext, tableId, rowIds);
+	}
+	async renameRow(tableId, rowId, nextRowId) {
+		return renameRow(this._scopeContext, tableId, rowId, nextRowId);
+	}
+	async commit(comment) {
+		const data = await commit(this._scopeContext, comment);
+		await this.refreshDraftRevisionId();
+		this.notifyScopesOnCurrentBranch();
+		return data;
+	}
+	async revertChanges() {
+		await revertChanges(this._scopeContext);
+		await this.refreshDraftRevisionId();
+		this.notifyScopesOnCurrentBranch();
+	}
+	async refreshDraftRevisionId() {
+		this._revisionId = await fetchDraftRevisionId(this._client, {
+			organizationId: this._organizationId,
+			projectName: this._projectName,
+			branchName: this._branchName
+		});
+	}
+	notifyScopesOnCurrentBranch() {
+		if (this._organizationId && this._projectName && this._branchName) {
+			const branchKey = `${this._organizationId}/${this._projectName}/${this._branchName}`;
+			this.notifyBranchChanged(branchKey);
+		}
 	}
 };
 
 //#endregion
-export { RevisiumClient };
+export { RevisiumClient, RevisiumScope, client, sdk_gen_exports as sdk };
 //# sourceMappingURL=index.mjs.map