@centia-io/sdk 0.0.44 → 0.0.45

package/dist/centia-io-sdk.cjs

@@ -436,128 +436,231 @@ var PasswordFlow = class {
 };
 
 //#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;
-
-//#endregion
-//#region src/util/get-response.ts
 /**
-* @author     Martin Høgh <mh@mapcentia.com>
-* @copyright  2013-2026 MapCentia ApS
-* @license    https://opensource.org/license/mit  The MIT License
+* 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() },
+* });
+* ```
 */
-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;
+function createCentiaClient(config) {
+	return new CentiaHttpClient(config);
+}
 
 //#endregion
-//#region src/Sql.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.
 */
+/**
+* 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
 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"
+		});
 	}
 };
 
@@ -596,15 +699,15 @@ var Claims = class {
 
 //#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"
+		});
 	}
 };
 
@@ -652,49 +755,55 @@ var Ws = class {
 
 //#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);
 }
@@ -716,26 +825,26 @@ function extractDataFromResponse(method, res) {
 		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,
@@ -745,11 +854,11 @@ async function dispatch(name, paramsLike) {
 	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);
 		};
 	} });
 }
@@ -1346,36 +1455,35 @@ var TableQueryImpl = class {
 			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;
 			}
 		}();
 	}
@@ -1419,55 +1527,56 @@ var TableQueryImpl = class {
 					}
 					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;
 			}
 		}();
 	}
@@ -1502,45 +1611,46 @@ var TableQueryImpl = class {
 					}
 					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;
 			}
 		}();
 	}
@@ -1549,6 +1659,552 @@ function createSqlBuilder(schema) {
 	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
 /**
@@ -1559,6 +2215,7 @@ function createSqlBuilder(schema) {
 */
 
 //#endregion
+exports.CentiaApiError = CentiaApiError;
 exports.Claims = Claims;
 exports.CodeFlow = CodeFlow;
 exports.Gql = Gql;
@@ -1573,4 +2230,7 @@ exports.Tables = Tables;
 exports.Users = Users;
 exports.Ws = Ws;
 exports.createApi = createApi;
-exports.createSqlBuilder = createSqlBuilder;
+exports.createCentiaAdminClient = createCentiaAdminClient;
+exports.createCentiaClient = createCentiaClient;
+exports.createSqlBuilder = createSqlBuilder;
+exports.isCentiaApiError = isCentiaApiError;