@centia-io/sdk 0.0.44 → 0.0.46

package/dist/centia-io-sdk.umd.js

@@ -441,128 +441,231 @@
 	};
 
 //#endregion
-//#region src/util/request-headers.ts
+//#region src/http/errors.ts
 /**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
+	* Normalized error thrown by all SDK HTTP operations.
+	* CLI and Web should catch this type for consistent error handling.
 	*/
-	const getHeaders = async (contentType = "application/json") => {
-		if (!await isLogin(new Gc2Service(getOptions()))) return Promise.reject("Is not logged in");
-		const { accessToken } = getTokens();
-		const headers = {
-			Accept: "application/json",
-			Cookie: "XDEBUG_SESSION=XDEBUG_ECLIPSE",
-			Authorization: accessToken ? "Bearer " + accessToken : null
-		};
-		if (contentType) headers["Content-Type"] = contentType;
-		return headers;
+	var CentiaApiError = class extends Error {
+		constructor(opts) {
+			super(opts.message);
+			this.name = "CentiaApiError";
+			if (opts.cause !== void 0) this.cause = opts.cause;
+			this.status = opts.status;
+			this.code = opts.code;
+			this.details = opts.details;
+			this.requestId = opts.requestId;
+			this.method = opts.method;
+			this.url = opts.url;
+		}
 	};
-	var request_headers_default = getHeaders;
+	/** Type guard for CentiaApiError. */
+	function isCentiaApiError(e) {
+		return e instanceof CentiaApiError;
+	}
 
 //#endregion
-//#region src/util/make-request.ts
+//#region src/http/client.ts
 /**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
+	* Unified HTTP client for the Centia API.
+	* Works in both Node.js and browser environments.
 	*/
-	const make = async (version, resource, method, payload, contentType = "application/json") => {
-		const options = getOptions();
-		let request = {
-			method,
-			headers: await request_headers_default(contentType),
-			redirect: "manual"
-		};
-		if (payload) request.body = contentType === "application/json" ? JSON.stringify(payload) : payload;
-		if (version !== null) return await fetch(options.host + `/api/v${version}/${resource}`, request);
-		else return await fetch(options.host + `/api/${resource}`, request);
+	var CentiaHttpClient = class {
+		constructor(config) {
+			this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+			this.auth = config.auth ?? {};
+			this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+			this.userAgent = config.userAgent;
+		}
+		/**
+		* Execute an HTTP request against the Centia API.
+		* Returns parsed JSON on success. Throws CentiaApiError on non-expected status.
+		*/
+		async request(opts) {
+			return (await this.requestFull(opts)).body;
+		}
+		/**
+		* Execute an HTTP request and return the full response including headers.
+		* Useful for operations that return Location headers (POST 201, PATCH 303).
+		*/
+		async requestFull(opts) {
+			const url = this.buildUrl(opts.path, opts.query);
+			const headers = await this.buildHeaders(opts);
+			const init = {
+				method: opts.method,
+				headers,
+				redirect: "manual"
+			};
+			if (opts.body !== void 0 && opts.body !== null) init.body = this.resolveContentType(opts.contentType) === "application/json" ? JSON.stringify(opts.body) : opts.body;
+			const response = await this.fetchFn(url, init);
+			if (response.type === "opaqueredirect") {
+				if ((opts.expectedStatus ?? 200) === 303) return {
+					body: null,
+					status: 303,
+					getHeader: (name) => name.toLowerCase() === "location" ? response.url : null
+				};
+			}
+			return {
+				body: await this.handleResponse(response, opts, url),
+				status: response.status,
+				getHeader: (name) => response.headers.get(name)
+			};
+		}
+		buildUrl(path, query) {
+			const cleanPath = path.replace(/^\/+/, "");
+			let url = `${this.baseUrl}/${cleanPath}`;
+			if (query) {
+				const params = new URLSearchParams(query);
+				url += `?${params.toString()}`;
+			}
+			return url;
+		}
+		async buildHeaders(opts) {
+			const headers = { "Accept": opts.accept ?? "application/json" };
+			if (this.auth.getAccessToken) {
+				const token = await this.auth.getAccessToken();
+				if (token) headers["Authorization"] = `Bearer ${token}`;
+			}
+			if (this.auth.getHeaders) {
+				const authHeaders = await this.auth.getHeaders();
+				Object.assign(headers, authHeaders);
+			}
+			if (this.userAgent && typeof navigator === "undefined") headers["User-Agent"] = this.userAgent;
+			const ct = this.resolveContentType(opts.contentType);
+			if (ct) headers["Content-Type"] = ct;
+			return headers;
+		}
+		resolveContentType(contentType) {
+			if (contentType === null) return null;
+			return contentType ?? "application/json";
+		}
+		async handleResponse(response, opts, url) {
+			const expectedStatus = opts.expectedStatus ?? 200;
+			let bodyText = "";
+			try {
+				bodyText = await response.text();
+			} catch {}
+			let parsed = null;
+			if (bodyText) try {
+				parsed = JSON.parse(bodyText);
+			} catch {}
+			if (response.status !== expectedStatus) throw new CentiaApiError({
+				message: (parsed?.message ?? parsed?.error ?? bodyText) || `Unexpected status ${response.status}`,
+				status: response.status,
+				code: parsed?.code,
+				details: parsed,
+				requestId: response.headers.get("x-request-id") ?? void 0,
+				method: opts.method,
+				url
+			});
+			return parsed ?? (bodyText || null);
+		}
 	};
-	var make_request_default = make;
+	/**
+	* Create a new Centia HTTP client.
+	*
+	* Node.js usage:
+	* ```ts
+	* const client = createCentiaClient({
+	*   baseUrl: 'https://example.centia.io',
+	*   auth: { getAccessToken: async () => process.env.CENTIA_TOKEN },
+	* });
+	* ```
+	*
+	* Browser usage:
+	* ```ts
+	* const client = createCentiaClient({
+	*   baseUrl: 'https://example.centia.io',
+	*   auth: { getAccessToken: async () => getStoredToken() },
+	* });
+	* ```
+	*/
+	function createCentiaClient(config) {
+		return new CentiaHttpClient(config);
+	}
 
 //#endregion
-//#region src/util/get-response.ts
+//#region src/http/legacy.ts
 /**
 	* @author     Martin Høgh <mh@mapcentia.com>
 	* @copyright  2013-2026 MapCentia ApS
 	* @license    https://opensource.org/license/mit  The MIT License
 	*
+	* Legacy bridge: creates a CentiaHttpClient from storage-based options/tokens.
+	* Used by existing SDK modules when no explicit client is provided.
 	*/
-	const get = async (response, expectedCode) => {
-		let res = null;
-		let bodyText = "";
-		try {
-			bodyText = await response.text();
-		} catch (e) {}
-		if (bodyText) try {
-			res = JSON.parse(bodyText);
-		} catch (e) {}
-		if (response.status !== expectedCode) {
-			const msg = res && (res.message || res.error) || bodyText || `Unexpected status ${response.status}`;
-			throw new Error(msg);
-		}
-		return res;
-	};
-	var get_response_default = get;
+	/**
+	* Create a CentiaHttpClient backed by the legacy storage-based auth.
+	* The auth callback reads fresh tokens from storage on each request
+	* and auto-refreshes expired access tokens via the refresh token.
+	*/
+	function getLegacyClient() {
+		return new CentiaHttpClient({
+			baseUrl: getOptions().host,
+			auth: { getAccessToken: async () => {
+				if (!await isLogin(new Gc2Service(getOptions()))) return;
+				return getTokens().accessToken || void 0;
+			} }
+		});
+	}
 
 //#endregion
 //#region src/Sql.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Sql = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async exec(request) {
-			return await get_response_default(await make_request_default("4", `sql`, "POST", request), 200);
+			return this.client.request({
+				path: "api/v4/sql",
+				method: "POST",
+				body: request
+			});
 		}
 	};
 
 //#endregion
 //#region src/Rpc.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Rpc = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async call(request) {
-			return await get_response_default(await make_request_default("4", `call`, "POST", request), 200);
+			return this.client.request({
+				path: "api/v4/call",
+				method: "POST",
+				body: request
+			});
 		}
 	};
 
 //#endregion
 //#region src/Gql.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Gql = class {
-		constructor(schema) {
+		constructor(schema, client) {
 			this.schema = schema;
+			this.client = client ?? getLegacyClient();
 		}
 		async request(request) {
-			return await get_response_default(await make_request_default(null, `graphql/schema/${this.schema}`, "POST", request), 200);
+			return this.client.request({
+				path: `api/graphql/schema/${this.schema}`,
+				method: "POST",
+				body: request
+			});
 		}
 	};
 
 //#endregion
 //#region src/Meta.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Meta = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async query(rel) {
-			return await get_response_default(await make_request_default("3", `meta/${rel}`, "GET", null), 200);
+			return this.client.request({
+				path: `api/v4/meta/${rel}`,
+				method: "GET"
+			});
 		}
 	};
 
@@ -601,15 +704,15 @@
 
 //#endregion
 //#region src/Users.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Users = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async get(user) {
-			return await get_response_default(await make_request_default("4", `users/${user}`, "GET", null), 200);
+			return this.client.request({
+				path: `api/v4/users/${user}`,
+				method: "GET"
+			});
 		}
 	};
 
@@ -657,49 +760,55 @@
 
 //#endregion
 //#region src/Stats.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Stats = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async get() {
-			return await get_response_default(await make_request_default("4", `stats`, "GET", null), 200);
+			return this.client.request({
+				path: "api/v4/stats",
+				method: "GET"
+			});
 		}
 	};
 
 //#endregion
 //#region src/Tables.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	var Tables = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
 		async get(schema, table) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "GET", null), 200);
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "GET"
+			});
 		}
 		async create(schema, table, payload) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "POST", payload), 200);
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "POST",
+				body: payload
+			});
 		}
 		async patch(schema, table, payload) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "PATCH", payload), 200);
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "PATCH",
+				body: payload
+			});
 		}
 		async delete(schema, table) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "DELETE", null), 204);
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
 		}
 	};
 
 //#endregion
 //#region src/Api.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
 	function isPlainObject$1(v) {
 		return typeof v === "object" && v !== null && !Array.isArray(v);
 	}
@@ -721,26 +830,26 @@
 			if (!err || typeof err !== "object") throw new TypeError(`createApi: Invalid RPC error for method "${method}". Expected 'error' to be an object.`);
 			const code = err.code;
 			const message = err.message;
-			const data$1 = err.data;
+			const data = err.data;
 			const codeIsNum = typeof code === "number" && Number.isFinite(code);
 			const details = typeof message === "string" && message.length > 0 ? message : "Unknown error";
 			const e = /* @__PURE__ */ new Error(`createApi: RPC error for method "${method}"${codeIsNum ? ` (${code})` : ""}: ${details}`);
 			e.code = code;
-			if (data$1 !== void 0) e.data = data$1;
+			if (data !== void 0) e.data = data;
 			e.method = method;
 			e.name = "JsonRpcError";
 			throw e;
 		}
 		const result = res.result;
 		if (!result || typeof result !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing result object.`);
-		const data = result.data;
-		if (!Array.isArray(data)) throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected result.data to be an array.`);
-		return data;
+		const dataArr = result.data;
+		if (!Array.isArray(dataArr)) throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected result.data to be an array.`);
+		return dataArr;
 	}
-	async function dispatch(name, paramsLike) {
+	async function dispatch(name, paramsLike, client) {
 		if (typeof name !== "string" || name.length === 0) throw new TypeError("createApi: RPC method name must be a non-empty string.");
 		const params = validateParamsForMethod(String(name), paramsLike);
-		const rpc = new Rpc();
+		const rpc = new Rpc(client);
 		const request = {
 			jsonrpc: "2.0",
 			method: name,
@@ -750,11 +859,11 @@
 		const res = await rpc.call(request);
 		return extractDataFromResponse(String(name), res);
 	}
-	function createApi() {
+	function createApi(client) {
 		return new Proxy({}, { get(_target, prop) {
 			if (typeof prop !== "string") return void 0;
 			return (...args) => {
-				return dispatch(prop, args.length === 0 ? {} : args.length === 1 ? args[0] : args);
+				return dispatch(prop, args.length === 0 ? {} : args.length === 1 ? args[0] : args, client);
 			};
 		} });
 	}
@@ -1351,36 +1460,35 @@
 				returning: []
 			};
 			return new class {
-				constructor() {
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const cols = [];
-						const vals = [];
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						for (const key in state.values) {
-							const value = state.values[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							cols.push(`"${key}"`);
-							vals.push(`:${paramName}`);
-							params[paramName] = value;
-							addTypeHintForParam(type_hints, paramName, col, value);
-						}
-						const parts = [];
-						parts.push(`insert into "${schema.name}"."${table.name}" (${cols.join(", ")}) values (${vals.join(", ")})`);
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
+				returning(cols) {
+					state.returning = cols || [];
+					return this;
+				}
+				toSql() {
+					const colsArr = [];
+					const vals = [];
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					for (const key in state.values) {
+						const value = state.values[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						colsArr.push(`"${key}"`);
+						vals.push(`:${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					}
+					const parts = [];
+					parts.push(`insert into "${schema.name}"."${table.name}" (${colsArr.join(", ")}) values (${vals.join(", ")})`);
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					const req = {
+						q: parts.join(" "),
+						params: Object.keys(params).length > 0 ? params : void 0,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
 					};
+					return state.returning.length ? req : req;
 				}
 			}();
 		}
@@ -1424,55 +1532,56 @@
 						}
 						return this;
 					};
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						const setParts = [];
-						for (const key in state.values) {
-							const value = state.values[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							setParts.push(`"${key}" = :${paramName}`);
+				}
+				returning(cols) {
+					state.returning = cols || [];
+					return this;
+				}
+				toSql() {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const setParts = [];
+					for (const key in state.values) {
+						const value = state.values[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						setParts.push(`"${key}" = :${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					}
+					const whereClauses = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							whereClauses.push(`"${key}" is null`);
+						} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+							validateInArrayValues(col, key, value, "in");
+							whereClauses.push(`"${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							whereClauses.push(`"${key}" = :${paramName}`);
 							params[paramName] = value;
 							addTypeHintForParam(type_hints, paramName, col, value);
 						}
-						const whereClauses = [];
-						for (const key in state.where) {
-							const value = state.where[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							if (value === null) {
-								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-								whereClauses.push(`"${key}" is null`);
-							} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
-								validateInArrayValues(col, key, value, "in");
-								whereClauses.push(`"${key}" = ANY(:${paramName})`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							} else {
-								validateScalarForColumn(col, value, `column ${key}`);
-								whereClauses.push(`"${key}" = :${paramName}`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							}
-						}
-						const parts = [];
-						parts.push(`update "${schema.name}"."${table.name}" set ${setParts.join(", ")}`);
-						if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
+					}
+					const parts = [];
+					parts.push(`update "${schema.name}"."${table.name}" set ${setParts.join(", ")}`);
+					if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					const req = {
+						q: parts.join(" "),
+						params: Object.keys(params).length > 0 ? params : void 0,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
 					};
+					return state.returning.length ? req : req;
 				}
 			}();
 		}
@@ -1507,45 +1616,46 @@
 						}
 						return this;
 					};
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						const whereClauses = [];
-						for (const key in state.where) {
-							const value = state.where[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							if (value === null) {
-								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-								whereClauses.push(`"${key}" is null`);
-							} else if (Array.isArray(value)) {
-								validateInArrayValues(col, key, value, "in");
-								whereClauses.push(`"${key}" = ANY(:${paramName})`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							} else {
-								validateScalarForColumn(col, value, `column ${key}`);
-								whereClauses.push(`"${key}" = :${paramName}`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							}
+				}
+				returning(cols) {
+					state.returning = cols || [];
+					return this;
+				}
+				toSql() {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const whereClauses = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							whereClauses.push(`"${key}" is null`);
+						} else if (Array.isArray(value)) {
+							validateInArrayValues(col, key, value, "in");
+							whereClauses.push(`"${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							whereClauses.push(`"${key}" = :${paramName}`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
 						}
-						const parts = [];
-						parts.push(`delete from "${schema.name}"."${table.name}"`);
-						if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
+					}
+					const parts = [];
+					parts.push(`delete from "${schema.name}"."${table.name}"`);
+					if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					const req = {
+						q: parts.join(" "),
+						params: Object.keys(params).length > 0 ? params : void 0,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
 					};
+					return state.returning.length ? req : req;
 				}
 			}();
 		}
@@ -1554,6 +1664,552 @@
 		return { table: (name) => new TableQueryImpl(schema, String(name)) };
 	}
 
+//#endregion
+//#region src/provisioning/Schemas.ts
+	var Schemas = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getSchema(schema, opts) {
+			const path = schema ? `api/v4/schemas/${encodeURIComponent(schema)}` : "api/v4/schemas";
+			const query = {};
+			if (opts?.namesOnly) query.namesOnly = "true";
+			return this.client.request({
+				path,
+				method: "GET",
+				query: Object.keys(query).length > 0 ? query : void 0
+			});
+		}
+		async postSchema(body) {
+			return { location: (await this.client.requestFull({
+				path: "api/v4/schemas",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchSchema(schema, body) {
+			return { location: (await this.client.requestFull({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteSchema(schema) {
+			await this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Columns.ts
+	var Columns = class {
+		constructor(client) {
+			this.client = client;
+		}
+		basePath(schema, table) {
+			return `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}/columns`;
+		}
+		async getColumn(schema, table, column) {
+			const path = column ? `${this.basePath(schema, table)}/${encodeURIComponent(column)}` : this.basePath(schema, table);
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postColumn(schema, table, body) {
+			return { location: (await this.client.requestFull({
+				path: this.basePath(schema, table),
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchColumn(schema, table, column, body) {
+			return { location: (await this.client.requestFull({
+				path: `${this.basePath(schema, table)}/${encodeURIComponent(column)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteColumn(schema, table, column) {
+			await this.client.request({
+				path: `${this.basePath(schema, table)}/${encodeURIComponent(column)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Constraints.ts
+	var Constraints = class {
+		constructor(client) {
+			this.client = client;
+		}
+		basePath(schema, table) {
+			return `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}/constraints`;
+		}
+		async getConstraint(schema, table, constraint) {
+			const path = constraint ? `${this.basePath(schema, table)}/${encodeURIComponent(constraint)}` : this.basePath(schema, table);
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postConstraint(schema, table, body) {
+			return { location: (await this.client.requestFull({
+				path: this.basePath(schema, table),
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteConstraint(schema, table, constraint) {
+			await this.client.request({
+				path: `${this.basePath(schema, table)}/${encodeURIComponent(constraint)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Indices.ts
+	var Indices = class {
+		constructor(client) {
+			this.client = client;
+		}
+		basePath(schema, table) {
+			return `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}/indices`;
+		}
+		async getIndex(schema, table, index) {
+			const path = index ? `${this.basePath(schema, table)}/${encodeURIComponent(index)}` : this.basePath(schema, table);
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postIndex(schema, table, body) {
+			return { location: (await this.client.requestFull({
+				path: this.basePath(schema, table),
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteIndex(schema, table, index) {
+			await this.client.request({
+				path: `${this.basePath(schema, table)}/${encodeURIComponent(index)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Sequences.ts
+	var Sequences = class {
+		constructor(client) {
+			this.client = client;
+		}
+		basePath(schema) {
+			return `api/v4/schemas/${encodeURIComponent(schema)}/sequences`;
+		}
+		async getSequence(schema, sequence) {
+			const path = sequence ? `${this.basePath(schema)}/${encodeURIComponent(sequence)}` : this.basePath(schema);
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postSequence(schema, body) {
+			return { location: (await this.client.requestFull({
+				path: this.basePath(schema),
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchSequence(schema, sequence, body) {
+			return { location: (await this.client.requestFull({
+				path: `${this.basePath(schema)}/${encodeURIComponent(sequence)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteSequence(schema, sequence) {
+			await this.client.request({
+				path: `${this.basePath(schema)}/${encodeURIComponent(sequence)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Tables.ts
+	var ProvisioningTables = class {
+		constructor(client) {
+			this.client = client;
+		}
+		basePath(schema) {
+			return `api/v4/schemas/${encodeURIComponent(schema)}/tables`;
+		}
+		async getTable(schema, table) {
+			const path = table ? `${this.basePath(schema)}/${encodeURIComponent(table)}` : this.basePath(schema);
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postTable(schema, body) {
+			return { location: (await this.client.requestFull({
+				path: this.basePath(schema),
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchTable(schema, table, body) {
+			return { location: (await this.client.requestFull({
+				path: `${this.basePath(schema)}/${encodeURIComponent(table)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteTable(schema, table) {
+			await this.client.request({
+				path: `${this.basePath(schema)}/${encodeURIComponent(table)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Users.ts
+	var ProvisioningUsers = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getUser(name) {
+			const path = name ? `api/v4/users/${encodeURIComponent(name)}` : "api/v4/users";
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postUser(body) {
+			return { location: (await this.client.requestFull({
+				path: "api/v4/users",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchUser(name, body) {
+			return { location: (await this.client.requestFull({
+				path: `api/v4/users/${encodeURIComponent(name)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteUser(name) {
+			await this.client.request({
+				path: `api/v4/users/${encodeURIComponent(name)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Clients.ts
+	var ProvisioningClients = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getClient(id) {
+			const path = id ? `api/v4/clients/${encodeURIComponent(id)}` : "api/v4/clients";
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postClient(body) {
+			const res = await this.client.requestFull({
+				path: "api/v4/clients",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			});
+			return {
+				location: res.getHeader("Location") ?? "",
+				secret: res.body.secret
+			};
+		}
+		async patchClient(id, body) {
+			return { location: (await this.client.requestFull({
+				path: `api/v4/clients/${encodeURIComponent(id)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteClient(id) {
+			await this.client.request({
+				path: `api/v4/clients/${encodeURIComponent(id)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Rules.ts
+	var Rules = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getRule(id) {
+			const path = id != null ? `api/v4/rules/${encodeURIComponent(id)}` : "api/v4/rules";
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postRule(body) {
+			return this.client.request({
+				path: "api/v4/rules",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			});
+		}
+		async patchRule(id, body) {
+			return this.client.request({
+				path: `api/v4/rules/${encodeURIComponent(id)}`,
+				method: "PATCH",
+				body
+			});
+		}
+		async deleteRule(id) {
+			await this.client.request({
+				path: `api/v4/rules/${encodeURIComponent(id)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/Privileges.ts
+	var Privileges = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getPrivileges(schema, table) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}/privileges`,
+				method: "GET"
+			});
+		}
+		async patchPrivileges(schema, table, body) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}/privileges`,
+				method: "PATCH",
+				body
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/RpcMethods.ts
+	var RpcMethods = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getRpc(method) {
+			const path = method ? `api/v4/methods/${encodeURIComponent(method)}` : "api/v4/methods";
+			return this.client.request({
+				path,
+				method: "GET"
+			});
+		}
+		async postRpc(body) {
+			return { location: (await this.client.requestFull({
+				path: "api/v4/methods",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			})).getHeader("Location") ?? "" };
+		}
+		async patchRpc(method, body) {
+			return { location: (await this.client.requestFull({
+				path: `api/v4/methods/${encodeURIComponent(method)}`,
+				method: "PATCH",
+				body,
+				expectedStatus: 303
+			})).getHeader("Location") ?? "" };
+		}
+		async deleteRpc(method) {
+			await this.client.request({
+				path: `api/v4/methods/${encodeURIComponent(method)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+		async postCallDry(body) {
+			return this.client.request({
+				path: "api/v4/call/dry",
+				method: "POST",
+				body
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/MetadataWrite.ts
+	var MetadataWrite = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async patchMetaData(body) {
+			return this.client.request({
+				path: "api/v4/meta",
+				method: "PATCH",
+				body
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/TypeScriptInterfaces.ts
+	var TypeScriptInterfaces = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async getTypeScript() {
+			return this.client.request({
+				path: "api/v4/interfaces",
+				method: "GET",
+				accept: "text/plain"
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/FileImport.ts
+	var FileImport = class {
+		constructor(client) {
+			this.client = client;
+		}
+		/**
+		* Upload a file via multipart/form-data.
+		* In Node.js, pass a FormData instance. In browsers, pass a native FormData.
+		*/
+		async postFileUpload(formData) {
+			return this.client.request({
+				path: "api/v4/file/upload",
+				method: "POST",
+				body: formData,
+				contentType: null,
+				expectedStatus: 201
+			});
+		}
+		async postFileProcess(body) {
+			return this.client.request({
+				path: "api/v4/file/process",
+				method: "POST",
+				body,
+				expectedStatus: 201
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/GitCommit.ts
+	var GitCommit = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async postCommit(body) {
+			return this.client.request({
+				path: "api/v4/commit",
+				method: "POST",
+				body
+			});
+		}
+	};
+
+//#endregion
+//#region src/provisioning/SqlNoToken.ts
+	var SqlNoToken = class {
+		constructor(client) {
+			this.client = client;
+		}
+		async postSqlNoToken(database, body) {
+			return this.client.request({
+				path: `api/v4/sql/database/${encodeURIComponent(database)}`,
+				method: "POST",
+				body
+			});
+		}
+	};
+
+//#endregion
+//#region src/admin.ts
+/**
+	* @author     Martin Høgh <mh@mapcentia.com>
+	* @copyright  2013-2026 MapCentia ApS
+	* @license    https://opensource.org/license/mit  The MIT License
+	*/
+	/**
+	* Create a Centia admin client with access to provisioning operations.
+	*
+	* ```ts
+	* const client = createCentiaAdminClient({
+	*   baseUrl: 'https://example.centia.io',
+	*   auth: { getAccessToken: async () => token },
+	* });
+	*
+	* await client.provisioning.schemas.postSchema({ name: 'myschema' });
+	* ```
+	*/
+	function createCentiaAdminClient(config) {
+		const http = new CentiaHttpClient(config);
+		return {
+			http,
+			provisioning: {
+				schemas: new Schemas(http),
+				tables: new ProvisioningTables(http),
+				columns: new Columns(http),
+				constraints: new Constraints(http),
+				indices: new Indices(http),
+				sequences: new Sequences(http),
+				users: new ProvisioningUsers(http),
+				clients: new ProvisioningClients(http),
+				rules: new Rules(http),
+				privileges: new Privileges(http),
+				rpcMethods: new RpcMethods(http),
+				metadata: new MetadataWrite(http),
+				typeScript: new TypeScriptInterfaces(http),
+				fileImport: new FileImport(http),
+				gitCommit: new GitCommit(http),
+				sqlNoToken: new SqlNoToken(http)
+			}
+		};
+	}
+
 //#endregion
 //#region src/index.ts
 /**
@@ -1564,6 +2220,7 @@
 	*/
 
 //#endregion
+exports.CentiaApiError = CentiaApiError;
 exports.Claims = Claims;
 exports.CodeFlow = CodeFlow;
 exports.Gql = Gql;
@@ -1578,5 +2235,8 @@ exports.Tables = Tables;
 exports.Users = Users;
 exports.Ws = Ws;
 exports.createApi = createApi;
+exports.createCentiaAdminClient = createCentiaAdminClient;
+exports.createCentiaClient = createCentiaClient;
 exports.createSqlBuilder = createSqlBuilder;
+exports.isCentiaApiError = isCentiaApiError;
 });