@centia-io/sdk 0.0.43 → 0.0.45

package/dist/centia-io-sdk.cjs

@@ -80,6 +80,12 @@ function getStorage() {
 
 //#endregion
 //#region src/util/utils.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 const generatePkceChallenge = async () => {
 	const generateRandomString = () => {
 		const array = new Uint32Array(28);
@@ -161,7 +167,8 @@ const setOptions = (options) => {
 	getStorage().setItem("gc2_options", JSON.stringify({
 		"clientId": options.clientId,
 		"host": options.host,
-		"redirectUri": options.redirectUri
+		"redirectUri": options.redirectUri,
+		"clientSecret": options.clientSecret || null
 	}));
 };
 const getOptions = () => {
@@ -188,6 +195,12 @@ const clearNonce = () => {
 
 //#endregion
 //#region src/services/gc2.services.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var Gc2Service = class {
 	constructor(options) {
 		this.options = options;
@@ -298,6 +311,7 @@ var Gc2Service = class {
 		const path = `${this.host}/api/v4/oauth`;
 		return this.request(this.buildUrl(path), "POST", {
 			client_id: this.options.clientId,
+			client_secret: this.options.clientSecret,
 			grant_type: "password",
 			username,
 			password,
@@ -323,6 +337,12 @@ var Gc2Service = class {
 
 //#endregion
 //#region src/CodeFlow.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var CodeFlow = class {
 	constructor(options) {
 		this.options = options;
@@ -381,6 +401,12 @@ var CodeFlow = class {
 
 //#endregion
 //#region src/PasswordFlow.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var PasswordFlow = class {
 	constructor(options) {
 		this.options = options;
@@ -395,7 +421,8 @@ var PasswordFlow = class {
 		setOptions({
 			clientId: this.options.clientId,
 			host: this.options.host,
-			redirectUri: ""
+			redirectUri: "",
+			clientSecret: this.options.clientSecret
 		});
 	}
 	signOut() {
@@ -409,79 +436,242 @@ var PasswordFlow = class {
 };
 
 //#endregion
-//#region src/util/request-headers.ts
-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;
+//#region src/http/errors.ts
+/**
+* Normalized error thrown by all SDK HTTP operations.
+* CLI and Web should catch this type for consistent error handling.
+*/
+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
-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;
-	return await fetch(options.host + `/api/v${version}/${resource}`, request);
+//#region src/http/client.ts
+/**
+* Unified HTTP client for the Centia API.
+* Works in both Node.js and browser environments.
+*/
+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
-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;
+//#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
 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
+var Gql = class {
+	constructor(schema, client) {
+		this.schema = schema;
+		this.client = client ?? getLegacyClient();
+	}
+	async request(request) {
+		return this.client.request({
+			path: `api/graphql/schema/${this.schema}`,
+			method: "POST",
+			body: request
+		});
 	}
 };
 
 //#endregion
 //#region src/Meta.ts
 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"
+		});
 	}
 };
 
 //#endregion
 //#region src/Status.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var Status = class {
 	isAuth() {
 		const tokens = getTokens();
@@ -494,6 +684,12 @@ var Status = class {
 
 //#endregion
 //#region src/Claims.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var Claims = class {
 	get() {
 		const tokens = getTokens().accessToken;
@@ -504,13 +700,25 @@ var Claims = class {
 //#endregion
 //#region src/Users.ts
 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"
+		});
 	}
 };
 
 //#endregion
 //#region src/Ws.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var Ws = class {
 	constructor(options) {
 		this.options = options;
@@ -548,25 +756,49 @@ var Ws = class {
 //#endregion
 //#region src/Stats.ts
 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
 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
+		});
 	}
 };
 
@@ -593,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,
@@ -622,17 +854,23 @@ 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);
 		};
 	} });
 }
 
 //#endregion
 //#region src/SignUp.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
 var SignUp = class {
 	constructor(options) {
 		this.options = options;
@@ -1422,8 +1660,565 @@ function createSqlBuilder(schema) {
 }
 
 //#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
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
+
+//#endregion
+exports.CentiaApiError = CentiaApiError;
 exports.Claims = Claims;
 exports.CodeFlow = CodeFlow;
+exports.Gql = Gql;
 exports.Meta = Meta;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
@@ -1435,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;