@centia-io/sdk 0.0.43 → 0.0.45

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

@@ -5,1007 +5,1178 @@
 })(this, function(exports) {
 
 //#region src/util/jwt-decode.ts
-var InvalidTokenError = class extends Error {};
-InvalidTokenError.prototype.name = "InvalidTokenError";
-function b64DecodeUnicode(str) {
-	return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
-		let code = p.charCodeAt(0).toString(16).toUpperCase();
-		if (code.length < 2) code = "0" + code;
-		return "%" + code;
-	}));
-}
-function base64UrlDecode(str) {
-	let output = str.replace(/-/g, "+").replace(/_/g, "/");
-	switch (output.length % 4) {
-		case 0: break;
-		case 2:
-			output += "==";
-			break;
-		case 3:
-			output += "=";
-			break;
-		default: throw new Error("base64 string is not of the correct length");
-	}
-	try {
-		return b64DecodeUnicode(output);
-	} catch (err) {
-		return atob(output);
-	}
-}
-function jwtDecode(token, options) {
-	if (typeof token !== "string") throw new InvalidTokenError("Invalid token specified: must be a string");
-	options ||= {};
-	const pos = options.header === true ? 0 : 1;
-	const part = token.split(".")[pos];
-	if (typeof part !== "string") throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
-	let decoded;
-	try {
-		decoded = base64UrlDecode(part);
-	} catch (e) {
-		throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+	var InvalidTokenError = class extends Error {};
+	InvalidTokenError.prototype.name = "InvalidTokenError";
+	function b64DecodeUnicode(str) {
+		return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+			let code = p.charCodeAt(0).toString(16).toUpperCase();
+			if (code.length < 2) code = "0" + code;
+			return "%" + code;
+		}));
+	}
+	function base64UrlDecode(str) {
+		let output = str.replace(/-/g, "+").replace(/_/g, "/");
+		switch (output.length % 4) {
+			case 0: break;
+			case 2:
+				output += "==";
+				break;
+			case 3:
+				output += "=";
+				break;
+			default: throw new Error("base64 string is not of the correct length");
+		}
+		try {
+			return b64DecodeUnicode(output);
+		} catch (err) {
+			return atob(output);
+		}
 	}
-	try {
-		return JSON.parse(decoded);
-	} catch (e) {
-		throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+	function jwtDecode(token, options) {
+		if (typeof token !== "string") throw new InvalidTokenError("Invalid token specified: must be a string");
+		options ||= {};
+		const pos = options.header === true ? 0 : 1;
+		const part = token.split(".")[pos];
+		if (typeof part !== "string") throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+		let decoded;
+		try {
+			decoded = base64UrlDecode(part);
+		} catch (e) {
+			throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+		}
+		try {
+			return JSON.parse(decoded);
+		} catch (e) {
+			throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+		}
 	}
-}
 
 //#endregion
 //#region src/util/storage.ts
-var MemoryStorage = class {
-	constructor() {
-		this.store = /* @__PURE__ */ new Map();
-	}
-	getItem(key) {
-		return this.store.has(key) ? this.store.get(key) : null;
-	}
-	setItem(key, value) {
-		this.store.set(key, String(value));
-	}
-	removeItem(key) {
-		this.store.delete(key);
+	var MemoryStorage = class {
+		constructor() {
+			this.store = /* @__PURE__ */ new Map();
+		}
+		getItem(key) {
+			return this.store.has(key) ? this.store.get(key) : null;
+		}
+		setItem(key, value) {
+			this.store.set(key, String(value));
+		}
+		removeItem(key) {
+			this.store.delete(key);
+		}
+	};
+	let cached = null;
+	function getStorage() {
+		if (cached) return cached;
+		try {
+			const g$1 = typeof globalThis !== "undefined" ? globalThis : window;
+			if (g$1 && g$1.localStorage && typeof g$1.localStorage.getItem === "function") {
+				cached = g$1.localStorage;
+				return cached;
+			}
+		} catch (e) {}
+		const g = typeof globalThis !== "undefined" ? globalThis : {};
+		if (!g.__gc2_memory_storage) g.__gc2_memory_storage = new MemoryStorage();
+		cached = g.__gc2_memory_storage;
+		return cached;
 	}
-};
-let cached = null;
-function getStorage() {
-	if (cached) return cached;
-	try {
-		const g$1 = typeof globalThis !== "undefined" ? globalThis : window;
-		if (g$1 && g$1.localStorage && typeof g$1.localStorage.getItem === "function") {
-			cached = g$1.localStorage;
-			return cached;
-		}
-	} catch (e) {}
-	const g = typeof globalThis !== "undefined" ? globalThis : {};
-	if (!g.__gc2_memory_storage) g.__gc2_memory_storage = new MemoryStorage();
-	cached = g.__gc2_memory_storage;
-	return cached;
-}
 
 //#endregion
 //#region src/util/utils.ts
-const generatePkceChallenge = async () => {
-	const generateRandomString = () => {
-		const array = new Uint32Array(28);
-		crypto.getRandomValues(array);
-		return Array.from(array, (dec) => ("0" + dec.toString(16)).substr(-2)).join("");
+/**
+	* @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);
+			crypto.getRandomValues(array);
+			return Array.from(array, (dec) => ("0" + dec.toString(16)).substr(-2)).join("");
+		};
+		const sha256 = (plain) => {
+			const data = new TextEncoder().encode(plain);
+			return crypto.subtle.digest("SHA-256", data);
+		};
+		const base64urlEncode = (str) => {
+			return btoa(String.fromCharCode.apply(null, [...new Uint8Array(str)])).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+		};
+		async function pkceChallengeFromVerifier(v) {
+			return base64urlEncode(await sha256(v));
+		}
+		const { state, codeVerifier } = {
+			state: generateRandomString(),
+			codeVerifier: generateRandomString()
+		};
+		return {
+			state,
+			codeVerifier,
+			codeChallenge: await pkceChallengeFromVerifier(codeVerifier)
+		};
 	};
-	const sha256 = (plain) => {
-		const data = new TextEncoder().encode(plain);
-		return crypto.subtle.digest("SHA-256", data);
+	const isTokenExpired = (token) => {
+		let isJwtExpired = false;
+		const { exp } = jwtDecode(token);
+		const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+		if (exp) {
+			if (currentTime > exp) isJwtExpired = true;
+		}
+		return isJwtExpired;
 	};
-	const base64urlEncode = (str) => {
-		return btoa(String.fromCharCode.apply(null, [...new Uint8Array(str)])).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	const claims = (token) => {
+		return jwtDecode(token);
 	};
-	async function pkceChallengeFromVerifier(v) {
-		return base64urlEncode(await sha256(v));
-	}
-	const { state, codeVerifier } = {
-		state: generateRandomString(),
-		codeVerifier: generateRandomString()
+	const isLogin = async (gc2) => {
+		const { accessToken, refreshToken } = getTokens();
+		if (!accessToken && !refreshToken) return false;
+		if (!accessToken || accessToken && isTokenExpired(accessToken)) {
+			if (refreshToken && isTokenExpired(refreshToken)) {
+				clearTokens();
+				clearOptions();
+				throw new Error("Refresh token has expired. Please login again.");
+			}
+			if (refreshToken) try {
+				const data = await gc2.getRefreshToken(refreshToken);
+				setTokens({
+					accessToken: data.access_token,
+					refreshToken,
+					idToken: data?.id_token
+				});
+				console.log("Access token refreshed");
+			} catch (e) {
+				throw new Error("Could not get refresh token.");
+			}
+		}
+		return true;
 	};
-	return {
-		state,
-		codeVerifier,
-		codeChallenge: await pkceChallengeFromVerifier(codeVerifier)
+	const setTokens = (tokens) => {
+		getStorage().setItem("gc2_tokens", JSON.stringify({
+			"accessToken": tokens.accessToken,
+			"refreshToken": tokens.refreshToken,
+			"idToken": tokens?.idToken || ""
+		}));
 	};
-};
-const isTokenExpired = (token) => {
-	let isJwtExpired = false;
-	const { exp } = jwtDecode(token);
-	const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
-	if (exp) {
-		if (currentTime > exp) isJwtExpired = true;
-	}
-	return isJwtExpired;
-};
-const claims = (token) => {
-	return jwtDecode(token);
-};
-const isLogin = async (gc2) => {
-	const { accessToken, refreshToken } = getTokens();
-	if (!accessToken && !refreshToken) return false;
-	if (!accessToken || accessToken && isTokenExpired(accessToken)) {
-		if (refreshToken && isTokenExpired(refreshToken)) {
-			clearTokens();
-			clearOptions();
-			throw new Error("Refresh token has expired. Please login again.");
-		}
-		if (refreshToken) try {
-			const data = await gc2.getRefreshToken(refreshToken);
-			setTokens({
-				accessToken: data.access_token,
-				refreshToken,
-				idToken: data?.id_token
-			});
-			console.log("Access token refreshed");
-		} catch (e) {
-			throw new Error("Could not get refresh token.");
-		}
-	}
-	return true;
-};
-const setTokens = (tokens) => {
-	getStorage().setItem("gc2_tokens", JSON.stringify({
-		"accessToken": tokens.accessToken,
-		"refreshToken": tokens.refreshToken,
-		"idToken": tokens?.idToken || ""
-	}));
-};
-const getTokens = () => {
-	const str = getStorage().getItem("gc2_tokens");
-	const tokens = str ? JSON.parse(str) : {};
-	return {
-		accessToken: tokens?.accessToken || "",
-		refreshToken: tokens?.refreshToken || "",
-		idToken: tokens?.idToken || ""
+	const getTokens = () => {
+		const str = getStorage().getItem("gc2_tokens");
+		const tokens = str ? JSON.parse(str) : {};
+		return {
+			accessToken: tokens?.accessToken || "",
+			refreshToken: tokens?.refreshToken || "",
+			idToken: tokens?.idToken || ""
+		};
+	};
+	const setOptions = (options) => {
+		getStorage().setItem("gc2_options", JSON.stringify({
+			"clientId": options.clientId,
+			"host": options.host,
+			"redirectUri": options.redirectUri,
+			"clientSecret": options.clientSecret || null
+		}));
+	};
+	const getOptions = () => {
+		const str = getStorage().getItem("gc2_options");
+		const options = str ? JSON.parse(str) : {};
+		return {
+			clientId: options?.clientId || "",
+			host: options?.host || "",
+			redirectUri: options?.redirectUri || ""
+		};
 	};
-};
-const setOptions = (options) => {
-	getStorage().setItem("gc2_options", JSON.stringify({
-		"clientId": options.clientId,
-		"host": options.host,
-		"redirectUri": options.redirectUri
-	}));
-};
-const getOptions = () => {
-	const str = getStorage().getItem("gc2_options");
-	const options = str ? JSON.parse(str) : {};
-	return {
-		clientId: options?.clientId || "",
-		host: options?.host || "",
-		redirectUri: options?.redirectUri || ""
+	const clearTokens = () => {
+		getStorage().removeItem("gc2_tokens");
+	};
+	const clearOptions = () => {
+		getStorage().removeItem("gc2_options");
+	};
+	const getNonce = () => {
+		return getStorage().getItem("gc2_nonce");
+	};
+	const clearNonce = () => {
+		getStorage().removeItem("gc2_nonce");
 	};
-};
-const clearTokens = () => {
-	getStorage().removeItem("gc2_tokens");
-};
-const clearOptions = () => {
-	getStorage().removeItem("gc2_options");
-};
-const getNonce = () => {
-	return getStorage().getItem("gc2_nonce");
-};
-const clearNonce = () => {
-	getStorage().removeItem("gc2_nonce");
-};
 
 //#endregion
 //#region src/services/gc2.services.ts
-var Gc2Service = class {
-	constructor(options) {
-		this.options = options;
-		this.host = options.host;
-	}
-	isCodeFlowOptions(options) {
-		return "redirectUri" in options;
-	}
-	isPasswordFlowOptions(options) {
-		return "username" in options;
-	}
-	isSignUpOptions(options) {
-		return "parentDb" in options;
-	}
-	buildUrl(path) {
-		if (path.startsWith("http://") || path.startsWith("https://")) return path;
-		return `${this.host}${path}`;
-	}
-	async request(url, method, body, contentType = "application/json") {
-		const headers = { "Content-Type": contentType };
-		let payload;
-		if (contentType === "application/json") payload = JSON.stringify(body);
-		else payload = new URLSearchParams(body).toString();
-		const response = await fetch(url, {
-			method,
-			headers,
-			body: payload
-		});
-		if (!response.ok) {
-			const errText = await response.text();
-			throw new Error(`HTTP error ${response.status}: ${errText}`);
+/**
+	* @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;
+			this.host = options.host;
 		}
-		return response.json();
-	}
-	async getDeviceCode() {
-		const path = this.options.deviceUri ?? `${this.host}/api/v4/oauth/device`;
-		return this.request(this.buildUrl(path), "POST", { client_id: this.options.clientId });
-	}
-	async pollToken(deviceCode, interval) {
-		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-		const getToken = async () => {
-			try {
-				return await this.request(this.buildUrl(path), "POST", {
-					client_id: this.options.clientId,
-					device_code: deviceCode,
-					grant_type: "device_code"
-				});
-			} catch (e) {
-				const err = JSON.parse(e.message.split(": ")[1]);
-				if (err.error === "authorization_pending") return null;
-				return err.error_description;
+		isCodeFlowOptions(options) {
+			return "redirectUri" in options;
+		}
+		isPasswordFlowOptions(options) {
+			return "username" in options;
+		}
+		isSignUpOptions(options) {
+			return "parentDb" in options;
+		}
+		buildUrl(path) {
+			if (path.startsWith("http://") || path.startsWith("https://")) return path;
+			return `${this.host}${path}`;
+		}
+		async request(url, method, body, contentType = "application/json") {
+			const headers = { "Content-Type": contentType };
+			let payload;
+			if (contentType === "application/json") payload = JSON.stringify(body);
+			else payload = new URLSearchParams(body).toString();
+			const response = await fetch(url, {
+				method,
+				headers,
+				body: payload
+			});
+			if (!response.ok) {
+				const errText = await response.text();
+				throw new Error(`HTTP error ${response.status}: ${errText}`);
 			}
-		};
-		let response = await getToken();
-		while (response === null) {
-			await new Promise((resolve) => setTimeout(resolve, interval * 1100));
-			response = await getToken();
+			return response.json();
 		}
-		if (typeof response === "string") throw new Error(response);
-		return response;
-	}
-	getAuthorizationCodeURL(codeChallenge, state) {
-		let redirectUri;
-		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-		else throw new Error("CodeFlow options required for this operation");
-		const base = this.options.authUri ?? `${this.host}/auth/`;
-		const params = new URLSearchParams();
-		const nonce = getNonce();
-		params.set("response_type", "code");
-		params.set("client_id", this.options.clientId);
-		params.set("redirect_uri", redirectUri);
-		params.set("state", state);
-		params.set("code_challenge", codeChallenge);
-		params.set("code_challenge_method", "S256");
-		if (nonce) params.set("nonce", nonce);
-		if (this.options.scope) params.set("scope", this.options.scope);
-		return `${base}?${params.toString()}`;
-	}
-	getSignUpURL() {
-		if (!this.isSignUpOptions(this.options)) throw new Error("CodeFlow options required for this operation");
-		const base = this.options.authUri ?? `${this.host}/signup/`;
-		const params = new URLSearchParams();
-		params.set("client_id", this.options.clientId);
-		params.set("parentdb", this.options.parentDb);
-		params.set("redirect_uri", this.options.redirectUri);
-		return `${base}?${params.toString()}`;
-	}
-	async getAuthorizationCodeToken(code, codeVerifier) {
-		let redirectUri;
-		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-		else throw new Error("CodeFlow options required for this operation");
-		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-		return this.request(this.buildUrl(path), "POST", {
-			client_id: this.options.clientId,
-			redirect_uri: redirectUri,
-			grant_type: "authorization_code",
-			code,
-			code_verifier: codeVerifier
-		}, "application/x-www-form-urlencoded");
-	}
-	async getPasswordToken() {
-		let username, password, database;
-		if (this.isPasswordFlowOptions(this.options)) {
-			username = this.options.username;
-			password = this.options.password;
-			database = this.options.database;
-		} else throw new Error("PasswordFlow options required for this operation");
-		const path = `${this.host}/api/v4/oauth`;
-		return this.request(this.buildUrl(path), "POST", {
-			client_id: this.options.clientId,
-			grant_type: "password",
-			username,
-			password,
-			database
-		});
-	}
-	async getRefreshToken(token) {
-		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-		return this.request(this.buildUrl(path), "POST", {
-			client_id: this.options.clientId,
-			grant_type: "refresh_token",
-			refresh_token: token
-		});
-	}
-	getSignOutURL() {
-		let redirectUri;
-		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-		else throw new Error("CodeFlow options required for this operation");
-		const params = new URLSearchParams({ redirect_uri: redirectUri });
-		return this.options.logoutUri ?? `${this.host}/signout?${params.toString()}`;
-	}
-};
+		async getDeviceCode() {
+			const path = this.options.deviceUri ?? `${this.host}/api/v4/oauth/device`;
+			return this.request(this.buildUrl(path), "POST", { client_id: this.options.clientId });
+		}
+		async pollToken(deviceCode, interval) {
+			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+			const getToken = async () => {
+				try {
+					return await this.request(this.buildUrl(path), "POST", {
+						client_id: this.options.clientId,
+						device_code: deviceCode,
+						grant_type: "device_code"
+					});
+				} catch (e) {
+					const err = JSON.parse(e.message.split(": ")[1]);
+					if (err.error === "authorization_pending") return null;
+					return err.error_description;
+				}
+			};
+			let response = await getToken();
+			while (response === null) {
+				await new Promise((resolve) => setTimeout(resolve, interval * 1100));
+				response = await getToken();
+			}
+			if (typeof response === "string") throw new Error(response);
+			return response;
+		}
+		getAuthorizationCodeURL(codeChallenge, state) {
+			let redirectUri;
+			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+			else throw new Error("CodeFlow options required for this operation");
+			const base = this.options.authUri ?? `${this.host}/auth/`;
+			const params = new URLSearchParams();
+			const nonce = getNonce();
+			params.set("response_type", "code");
+			params.set("client_id", this.options.clientId);
+			params.set("redirect_uri", redirectUri);
+			params.set("state", state);
+			params.set("code_challenge", codeChallenge);
+			params.set("code_challenge_method", "S256");
+			if (nonce) params.set("nonce", nonce);
+			if (this.options.scope) params.set("scope", this.options.scope);
+			return `${base}?${params.toString()}`;
+		}
+		getSignUpURL() {
+			if (!this.isSignUpOptions(this.options)) throw new Error("CodeFlow options required for this operation");
+			const base = this.options.authUri ?? `${this.host}/signup/`;
+			const params = new URLSearchParams();
+			params.set("client_id", this.options.clientId);
+			params.set("parentdb", this.options.parentDb);
+			params.set("redirect_uri", this.options.redirectUri);
+			return `${base}?${params.toString()}`;
+		}
+		async getAuthorizationCodeToken(code, codeVerifier) {
+			let redirectUri;
+			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+			else throw new Error("CodeFlow options required for this operation");
+			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+			return this.request(this.buildUrl(path), "POST", {
+				client_id: this.options.clientId,
+				redirect_uri: redirectUri,
+				grant_type: "authorization_code",
+				code,
+				code_verifier: codeVerifier
+			}, "application/x-www-form-urlencoded");
+		}
+		async getPasswordToken() {
+			let username, password, database;
+			if (this.isPasswordFlowOptions(this.options)) {
+				username = this.options.username;
+				password = this.options.password;
+				database = this.options.database;
+			} else throw new Error("PasswordFlow options required for this operation");
+			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,
+				database
+			});
+		}
+		async getRefreshToken(token) {
+			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+			return this.request(this.buildUrl(path), "POST", {
+				client_id: this.options.clientId,
+				grant_type: "refresh_token",
+				refresh_token: token
+			});
+		}
+		getSignOutURL() {
+			let redirectUri;
+			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+			else throw new Error("CodeFlow options required for this operation");
+			const params = new URLSearchParams({ redirect_uri: redirectUri });
+			return this.options.logoutUri ?? `${this.host}/signout?${params.toString()}`;
+		}
+	};
 
 //#endregion
 //#region src/CodeFlow.ts
-var CodeFlow = class {
-	constructor(options) {
-		this.options = options;
-		this.service = new Gc2Service(options);
-	}
-	async redirectHandle() {
-		const url = window.location.search;
-		const queryParams = new URLSearchParams(url);
-		if (queryParams.get("error")) throw new Error(`Failed to redirect: ${url}`);
-		const code = queryParams.get("code");
-		if (code) {
-			if (queryParams.get("state") !== getStorage().getItem("state")) throw new Error("Possible CSRF attack. Aborting login!");
-			try {
-				const { access_token, refresh_token, id_token } = await this.service.getAuthorizationCodeToken(code, getStorage().getItem("codeVerifier"));
-				setTokens({
-					accessToken: access_token,
-					refreshToken: refresh_token,
-					idToken: id_token
-				});
-				setOptions({
-					clientId: this.options.clientId,
-					host: this.options.host,
-					redirectUri: this.options.redirectUri
-				});
-				getStorage().removeItem("state");
-				getStorage().removeItem("codeVerifier");
-				const params = new URLSearchParams(window.location.search);
-				params.delete("code");
-				params.delete("state");
-				const loc = window.location;
-				const newUrl = loc.origin + loc.pathname + (params.size > 0 ? "?" + params.toString() : "");
-				history.pushState(null, "", newUrl);
-				return Promise.resolve(true);
-			} catch (e) {
-				throw new Error(e.message);
+/**
+	* @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;
+			this.service = new Gc2Service(options);
+		}
+		async redirectHandle() {
+			const url = window.location.search;
+			const queryParams = new URLSearchParams(url);
+			if (queryParams.get("error")) throw new Error(`Failed to redirect: ${url}`);
+			const code = queryParams.get("code");
+			if (code) {
+				if (queryParams.get("state") !== getStorage().getItem("state")) throw new Error("Possible CSRF attack. Aborting login!");
+				try {
+					const { access_token, refresh_token, id_token } = await this.service.getAuthorizationCodeToken(code, getStorage().getItem("codeVerifier"));
+					setTokens({
+						accessToken: access_token,
+						refreshToken: refresh_token,
+						idToken: id_token
+					});
+					setOptions({
+						clientId: this.options.clientId,
+						host: this.options.host,
+						redirectUri: this.options.redirectUri
+					});
+					getStorage().removeItem("state");
+					getStorage().removeItem("codeVerifier");
+					const params = new URLSearchParams(window.location.search);
+					params.delete("code");
+					params.delete("state");
+					const loc = window.location;
+					const newUrl = loc.origin + loc.pathname + (params.size > 0 ? "?" + params.toString() : "");
+					history.pushState(null, "", newUrl);
+					return Promise.resolve(true);
+				} catch (e) {
+					throw new Error(e.message);
+				}
 			}
+			return await isLogin(this.service);
 		}
-		return await isLogin(this.service);
-	}
-	async signIn() {
-		const { state, codeVerifier, codeChallenge } = await generatePkceChallenge();
-		getStorage().setItem("state", state);
-		getStorage().setItem("codeVerifier", codeVerifier);
-		window.location.assign(this.service.getAuthorizationCodeURL(codeChallenge, state));
-	}
-	signOut() {
-		this.clear();
-		window.location.assign(this.service.getSignOutURL());
-	}
-	clear() {
-		clearTokens();
-		clearOptions();
-		clearNonce();
-	}
-};
+		async signIn() {
+			const { state, codeVerifier, codeChallenge } = await generatePkceChallenge();
+			getStorage().setItem("state", state);
+			getStorage().setItem("codeVerifier", codeVerifier);
+			window.location.assign(this.service.getAuthorizationCodeURL(codeChallenge, state));
+		}
+		signOut() {
+			this.clear();
+			window.location.assign(this.service.getSignOutURL());
+		}
+		clear() {
+			clearTokens();
+			clearOptions();
+			clearNonce();
+		}
+	};
 
 //#endregion
 //#region src/PasswordFlow.ts
-var PasswordFlow = class {
-	constructor(options) {
-		this.options = options;
-		this.service = new Gc2Service(options);
-	}
-	async signIn() {
-		const { access_token, refresh_token } = await this.service.getPasswordToken();
-		setTokens({
-			accessToken: access_token,
-			refreshToken: refresh_token
-		});
-		setOptions({
-			clientId: this.options.clientId,
-			host: this.options.host,
-			redirectUri: ""
-		});
-	}
-	signOut() {
-		this.clear();
-	}
-	clear() {
-		clearTokens();
-		clearOptions();
-		clearNonce();
-	}
-};
+/**
+	* @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;
+			this.service = new Gc2Service(options);
+		}
+		async signIn() {
+			const { access_token, refresh_token } = await this.service.getPasswordToken();
+			setTokens({
+				accessToken: access_token,
+				refreshToken: refresh_token
+			});
+			setOptions({
+				clientId: this.options.clientId,
+				host: this.options.host,
+				redirectUri: "",
+				clientSecret: this.options.clientSecret
+			});
+		}
+		signOut() {
+			this.clear();
+		}
+		clear() {
+			clearTokens();
+			clearOptions();
+			clearNonce();
+		}
+	};
 
 //#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
+//#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;
+		}
 	};
-	if (contentType) headers["Content-Type"] = contentType;
-	return headers;
-};
-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"
+//#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);
+		}
 	};
-	if (payload) request.body = contentType === "application/json" ? JSON.stringify(payload) : payload;
-	return await fetch(options.host + `/api/v${version}/${resource}`, request);
-};
-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);
+//#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;
+			} }
+		});
 	}
-	return res;
-};
-var get_response_default = get;
 
 //#endregion
 //#region src/Sql.ts
-var Sql = class {
-	async exec(request) {
-		return await get_response_default(await make_request_default("4", `sql`, "POST", request), 200);
-	}
-};
+	var Sql = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async exec(request) {
+			return this.client.request({
+				path: "api/v4/sql",
+				method: "POST",
+				body: request
+			});
+		}
+	};
 
 //#endregion
 //#region src/Rpc.ts
-var Rpc = class {
-	async call(request) {
-		return await get_response_default(await make_request_default("4", `call`, "POST", request), 200);
-	}
-};
+	var Rpc = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async call(request) {
+			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 {
-	async query(rel) {
-		return await get_response_default(await make_request_default("3", `meta/${rel}`, "GET", null), 200);
-	}
-};
+	var Meta = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async query(rel) {
+			return this.client.request({
+				path: `api/v4/meta/${rel}`,
+				method: "GET"
+			});
+		}
+	};
 
 //#endregion
 //#region src/Status.ts
-var Status = class {
-	isAuth() {
-		const tokens = getTokens();
-		return !(!tokens.accessToken && !tokens.refreshToken);
-	}
-	getTokens() {
-		return getTokens();
-	}
-};
+/**
+	* @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();
+			return !(!tokens.accessToken && !tokens.refreshToken);
+		}
+		getTokens() {
+			return getTokens();
+		}
+	};
 
 //#endregion
 //#region src/Claims.ts
-var Claims = class {
-	get() {
-		const tokens = getTokens().accessToken;
-		return claims(tokens);
-	}
-};
+/**
+	* @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;
+			return claims(tokens);
+		}
+	};
 
 //#endregion
 //#region src/Users.ts
-var Users = class {
-	async get(user) {
-		return await get_response_default(await make_request_default("4", `users/${user}`, "GET", null), 200);
-	}
-};
+	var Users = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async get(user) {
+			return this.client.request({
+				path: `api/v4/users/${user}`,
+				method: "GET"
+			});
+		}
+	};
 
 //#endregion
 //#region src/Ws.ts
-var Ws = class {
-	constructor(options) {
-		this.options = options;
-		this.options.wsClient = this.options?.wsClient ?? WebSocket;
-	}
-	connect() {
-		const me = this;
-		const { accessToken } = getTokens();
-		const connect = () => {
-			let queryString = `?token=` + accessToken;
-			if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
-			const WSClass = this.options.wsClient;
-			const ws = new WSClass(this.options.host + `/` + queryString);
-			ws.onopen = function() {
-				console.log("WebSocket connected!");
-			};
-			ws.onmessage = function(event) {
-				me.options.callBack(event.data);
-			};
-			ws.onclose = function(event) {
-				if (accessToken !== "") {
-					console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
-					setTimeout(connect, 3e3);
-				}
-			};
-			ws.onerror = function(err) {
-				console.error("WebSocket error observed:", err);
-				ws.close();
+/**
+	* @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;
+			this.options.wsClient = this.options?.wsClient ?? WebSocket;
+		}
+		connect() {
+			const me = this;
+			const { accessToken } = getTokens();
+			const connect = () => {
+				let queryString = `?token=` + accessToken;
+				if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
+				const WSClass = this.options.wsClient;
+				const ws = new WSClass(this.options.host + `/` + queryString);
+				ws.onopen = function() {
+					console.log("WebSocket connected!");
+				};
+				ws.onmessage = function(event) {
+					me.options.callBack(event.data);
+				};
+				ws.onclose = function(event) {
+					if (accessToken !== "") {
+						console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
+						setTimeout(connect, 3e3);
+					}
+				};
+				ws.onerror = function(err) {
+					console.error("WebSocket error observed:", err);
+					ws.close();
+				};
 			};
-		};
-		if (accessToken !== "") connect();
-	}
-};
+			if (accessToken !== "") connect();
+		}
+	};
 
 //#endregion
 //#region src/Stats.ts
-var Stats = class {
-	async get() {
-		return await get_response_default(await make_request_default("4", `stats`, "GET", null), 200);
-	}
-};
+	var Stats = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async get() {
+			return this.client.request({
+				path: "api/v4/stats",
+				method: "GET"
+			});
+		}
+	};
 
 //#endregion
 //#region src/Tables.ts
-var Tables = class {
-	async get(schema, table) {
-		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "GET", null), 200);
-	}
-	async create(schema, table, payload) {
-		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "POST", payload), 200);
-	}
-	async patch(schema, table, payload) {
-		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "PATCH", payload), 200);
-	}
-	async delete(schema, table) {
-		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "DELETE", null), 204);
-	}
-};
+	var Tables = class {
+		constructor(client) {
+			this.client = client ?? getLegacyClient();
+		}
+		async get(schema, table) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "GET"
+			});
+		}
+		async create(schema, table, payload) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "POST",
+				body: payload
+			});
+		}
+		async patch(schema, table, payload) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "PATCH",
+				body: payload
+			});
+		}
+		async delete(schema, table) {
+			return this.client.request({
+				path: `api/v4/schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`,
+				method: "DELETE",
+				expectedStatus: 204
+			});
+		}
+	};
 
 //#endregion
 //#region src/Api.ts
-function isPlainObject$1(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function validateParamsForMethod(method, params) {
-	if (Array.isArray(params)) {
-		const badIndex = params.findIndex((p) => !isPlainObject$1(p));
-		if (badIndex !== -1) throw new TypeError(`createApi: Invalid argument at index ${badIndex} for RPC method "${method}". Expected a plain object.`);
+	function isPlainObject$1(v) {
+		return typeof v === "object" && v !== null && !Array.isArray(v);
+	}
+	function validateParamsForMethod(method, params) {
+		if (Array.isArray(params)) {
+			const badIndex = params.findIndex((p) => !isPlainObject$1(p));
+			if (badIndex !== -1) throw new TypeError(`createApi: Invalid argument at index ${badIndex} for RPC method "${method}". Expected a plain object.`);
+			return params;
+		}
+		if (params === void 0) return {};
+		if (!isPlainObject$1(params)) throw new TypeError(`createApi: Invalid argument for RPC method "${method}". Expected a plain object.`);
 		return params;
 	}
-	if (params === void 0) return {};
-	if (!isPlainObject$1(params)) throw new TypeError(`createApi: Invalid argument for RPC method "${method}". Expected a plain object.`);
-	return params;
-}
-function extractDataFromResponse(method, res) {
-	if (!res || typeof res !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected an object.`);
-	if (res.jsonrpc !== "2.0") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing or invalid jsonrpc version.`);
-	const err = res.error;
-	if (err !== void 0) {
-		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 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;
-		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;
-}
-async function dispatch(name, paramsLike) {
-	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 request = {
-		jsonrpc: "2.0",
-		method: name,
-		id: 1,
-		params
-	};
-	const res = await rpc.call(request);
-	return extractDataFromResponse(String(name), res);
-}
-function createApi() {
-	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);
+	function extractDataFromResponse(method, res) {
+		if (!res || typeof res !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected an object.`);
+		if (res.jsonrpc !== "2.0") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing or invalid jsonrpc version.`);
+		const err = res.error;
+		if (err !== void 0) {
+			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 = 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 !== 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 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, 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(client);
+		const request = {
+			jsonrpc: "2.0",
+			method: name,
+			id: 1,
+			params
 		};
-	} });
-}
+		const res = await rpc.call(request);
+		return extractDataFromResponse(String(name), res);
+	}
+	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, client);
+			};
+		} });
+	}
 
 //#endregion
 //#region src/SignUp.ts
-var SignUp = class {
-	constructor(options) {
-		this.options = options;
-		this.service = new Gc2Service(options);
-	}
-	async signUp() {
-		window.location.assign(this.service.getSignUpURL());
-	}
-};
+/**
+	* @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;
+			this.service = new Gc2Service(options);
+		}
+		async signUp() {
+			window.location.assign(this.service.getSignUpURL());
+		}
+	};
 
 //#endregion
 //#region src/SqlBuilder.ts
-function findTable(schema, name) {
-	const tbl = schema.tables.find((t) => t.name === name);
-	if (!tbl) throw new Error(`Table not found in schema: ${name}`);
-	return tbl;
-}
-function findColumn(table, name) {
-	const col = table.columns.find((c) => c.name === name);
-	if (!col) throw new Error(`Column not found in table ${table.name}: ${name}`);
-	return col;
-}
-function getPrimaryKeyColumns(table) {
-	const pk = (table.constraints || []).find((c) => c.constraint === "primary" && Array.isArray(c.columns) && c.columns.length > 0);
-	return pk ? pk.columns.map(String) : [];
-}
-function typeNameToHint(typname, isArray) {
-	if (!typname) return void 0;
-	const base = typname;
-	return isArray ? base + "[]" : base;
-}
-function addTypeHintForParam(typeHints, paramName, col, value) {
-	let isArr = col._is_array;
-	if (Array.isArray(value)) if (isArrayShapedGeomTypename(col._typname)) isArr = value.every(Array.isArray);
-	else isArr = true;
-	const hint = typeNameToHint(col._typname, isArr);
-	if (hint) typeHints[paramName] = hint;
-}
-function expectedScalarKind(typname) {
-	const t = typname.toLowerCase();
-	if (t === "int2" || t === "int4" || t === "int8" || t === "float4" || t === "float8") return "number";
-	if (t === "numeric" || t === "decimal") return "string";
-	if (t === "varchar" || t === "text" || t === "bpchar" || t === "char" || t === "date" || t === "time" || t === "timetz" || t === "timestamp" || t === "timestamptz") return "string";
-	if (t === "bool") return "boolean";
-	if (t === "json" || t === "jsonb") return "json";
-	if (t === "int4range" || t === "int8range" || t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "range";
-	if (t === "interval") return "interval";
-	if (t === "point" || t === "line" || t === "lseg" || t === "box" || t === "path" || t === "polygon" || t === "circle") return "geom";
-	return "unknown";
-}
-function isArrayShapedGeomTypename(typname) {
-	const t = typname.toLowerCase();
-	return t === "path" || t === "polygon";
-}
-function isArrayShapedGeomScalarValue(col, value) {
-	if (!Array.isArray(value)) return false;
-	if (!isArrayShapedGeomTypename(col._typname)) return false;
-	return !value.every(Array.isArray);
-}
-function expectedRangeInnerKind(typname) {
-	const t = typname.toLowerCase();
-	if (t === "int4range" || t === "int8range") return "number";
-	if (t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "string";
-	return "unknown";
-}
-function isPlainObject(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isFiniteNumber(n) {
-	return typeof n === "number" && Number.isFinite(n);
-}
-function isPointLike(v) {
-	if (!isPlainObject(v)) return false;
-	const x = v.x;
-	const y = v.y;
-	return isFiniteNumber(x) && isFiniteNumber(y);
-}
-function validateGeometryForColumn(col, value, context) {
-	const t = col._typname.toLowerCase();
-	if (t === "point") {
-		if (!isPointLike(value)) throw new Error(`Invalid value for ${context}. Expected Point { x: number, y: number }`);
-		return;
-	}
-	if (t === "line") {
-		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Line { A: number, B: number, C: number }`);
-		const A = value.A, B = value.B, C = value.C;
-		if (!isFiniteNumber(A) || !isFiniteNumber(B) || !isFiniteNumber(C)) throw new Error(`Invalid Line for ${context}. A, B, C must be finite numbers`);
-		return;
-	}
-	if (t === "lseg" || t === "box") {
-		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected ${t.toUpperCase()} { start: Point, end: Point }`);
-		const start = value.start;
-		const end = value.end;
-		if (!isPointLike(start) || !isPointLike(end)) throw new Error(`Invalid ${t} for ${context}. 'start' and 'end' must be Point { x, y }`);
-		return;
-	}
-	if (t === "path") {
-		if (!Array.isArray(value) || value.length < 1) throw new Error(`Invalid value for ${context}. Expected Path [isClosed: boolean, ...points: Point[]]`);
-		const [isClosed, ...points] = value;
-		if (typeof isClosed !== "boolean") throw new Error(`Invalid Path for ${context}. First element must be boolean (isClosed)`);
-		for (let i = 0; i < points.length; i++) if (!isPointLike(points[i])) throw new Error(`Invalid Path for ${context}. Element at index ${i + 1} must be Point { x, y }`);
-		return;
-	}
-	if (t === "polygon") {
-		if (!Array.isArray(value)) throw new Error(`Invalid value for ${context}. Expected Polygon as Point[]`);
-		for (let i = 0; i < value.length; i++) if (!isPointLike(value[i])) throw new Error(`Invalid Polygon for ${context}. Element at index ${i} must be Point { x, y }`);
-		return;
-	}
-	if (t === "circle") {
-		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Circle { center: Point, radius: number }`);
-		const center = value.center;
-		const radius = value.radius;
-		if (!isPointLike(center) || !isFiniteNumber(radius)) throw new Error(`Invalid Circle for ${context}. 'center' must be Point and 'radius' must be finite number`);
-		return;
-	}
-}
-function validateRangeForColumn(col, value, context) {
-	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected a range object for type ${col._typname}`);
-	const r = value;
-	const hasLower = Object.prototype.hasOwnProperty.call(r, "lower");
-	const hasUpper = Object.prototype.hasOwnProperty.call(r, "upper");
-	const hasLi = Object.prototype.hasOwnProperty.call(r, "lowerInclusive");
-	const hasUi = Object.prototype.hasOwnProperty.call(r, "upperInclusive");
-	if (!hasLower || !hasUpper || !hasLi || !hasUi) throw new Error(`Invalid range for ${context}. Required properties: lower, upper, lowerInclusive, upperInclusive`);
-	if (typeof r.lowerInclusive !== "boolean" || typeof r.upperInclusive !== "boolean") throw new Error(`Invalid range for ${context}. lowerInclusive and upperInclusive must be boolean`);
-	const inner = expectedRangeInnerKind(col._typname);
-	if (inner === "number") {
-		if (typeof r.lower !== "number" || !Number.isFinite(r.lower)) throw new Error(`Invalid range.lower for ${context}. Expected number for type ${col._typname}`);
-		if (typeof r.upper !== "number" || !Number.isFinite(r.upper)) throw new Error(`Invalid range.upper for ${context}. Expected number for type ${col._typname}`);
-	} else if (inner === "string") {
-		if (typeof r.lower !== "string") throw new Error(`Invalid range.lower for ${context}. Expected string for type ${col._typname}`);
-		if (typeof r.upper !== "string") throw new Error(`Invalid range.upper for ${context}. Expected string for type ${col._typname}`);
-	}
-}
-function validateIntervalForColumn(col, value, context) {
-	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected an interval object for type ${col._typname}`);
-	const v = value;
-	for (const k of [
-		"y",
-		"m",
-		"d",
-		"h",
-		"i",
-		"s"
-	]) {
-		if (!Object.prototype.hasOwnProperty.call(v, k)) throw new Error(`Invalid interval for ${context}. Missing property '${k}'`);
-		const num = v[k];
-		if (typeof num !== "number" || !Number.isFinite(num)) throw new Error(`Invalid interval.${String(k)} for ${context}. Expected finite number`);
-	}
-}
-function isValidJsonLike(value) {
-	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object" && value !== null;
-}
-function validateScalarForColumn(col, value, context) {
-	const kind = expectedScalarKind(col._typname);
-	if (kind === "unknown") return;
-	if (kind === "number") {
-		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid value for ${context}. Expected number for type ${col._typname}, got ${typeof value}`);
-		return;
-	}
-	if (kind === "string") {
-		if (typeof value !== "string") throw new Error(`Invalid value for ${context}. Expected string for type ${col._typname}, got ${typeof value}`);
-		return;
-	}
-	if (kind === "boolean") {
-		if (typeof value !== "boolean") throw new Error(`Invalid value for ${context}. Expected boolean for type ${col._typname}, got ${typeof value}`);
-		return;
-	}
-	if (kind === "json") {
-		if (!isValidJsonLike(value)) throw new Error(`Invalid value for ${context}. Expected JSON-compatible value for type ${col._typname}`);
-		return;
+	function findTable(schema, name) {
+		const tbl = schema.tables.find((t) => t.name === name);
+		if (!tbl) throw new Error(`Table not found in schema: ${name}`);
+		return tbl;
+	}
+	function findColumn(table, name) {
+		const col = table.columns.find((c) => c.name === name);
+		if (!col) throw new Error(`Column not found in table ${table.name}: ${name}`);
+		return col;
+	}
+	function getPrimaryKeyColumns(table) {
+		const pk = (table.constraints || []).find((c) => c.constraint === "primary" && Array.isArray(c.columns) && c.columns.length > 0);
+		return pk ? pk.columns.map(String) : [];
+	}
+	function typeNameToHint(typname, isArray) {
+		if (!typname) return void 0;
+		const base = typname;
+		return isArray ? base + "[]" : base;
+	}
+	function addTypeHintForParam(typeHints, paramName, col, value) {
+		let isArr = col._is_array;
+		if (Array.isArray(value)) if (isArrayShapedGeomTypename(col._typname)) isArr = value.every(Array.isArray);
+		else isArr = true;
+		const hint = typeNameToHint(col._typname, isArr);
+		if (hint) typeHints[paramName] = hint;
+	}
+	function expectedScalarKind(typname) {
+		const t = typname.toLowerCase();
+		if (t === "int2" || t === "int4" || t === "int8" || t === "float4" || t === "float8") return "number";
+		if (t === "numeric" || t === "decimal") return "string";
+		if (t === "varchar" || t === "text" || t === "bpchar" || t === "char" || t === "date" || t === "time" || t === "timetz" || t === "timestamp" || t === "timestamptz") return "string";
+		if (t === "bool") return "boolean";
+		if (t === "json" || t === "jsonb") return "json";
+		if (t === "int4range" || t === "int8range" || t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "range";
+		if (t === "interval") return "interval";
+		if (t === "point" || t === "line" || t === "lseg" || t === "box" || t === "path" || t === "polygon" || t === "circle") return "geom";
+		return "unknown";
+	}
+	function isArrayShapedGeomTypename(typname) {
+		const t = typname.toLowerCase();
+		return t === "path" || t === "polygon";
+	}
+	function isArrayShapedGeomScalarValue(col, value) {
+		if (!Array.isArray(value)) return false;
+		if (!isArrayShapedGeomTypename(col._typname)) return false;
+		return !value.every(Array.isArray);
+	}
+	function expectedRangeInnerKind(typname) {
+		const t = typname.toLowerCase();
+		if (t === "int4range" || t === "int8range") return "number";
+		if (t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "string";
+		return "unknown";
+	}
+	function isPlainObject(v) {
+		return typeof v === "object" && v !== null && !Array.isArray(v);
+	}
+	function isFiniteNumber(n) {
+		return typeof n === "number" && Number.isFinite(n);
+	}
+	function isPointLike(v) {
+		if (!isPlainObject(v)) return false;
+		const x = v.x;
+		const y = v.y;
+		return isFiniteNumber(x) && isFiniteNumber(y);
+	}
+	function validateGeometryForColumn(col, value, context) {
+		const t = col._typname.toLowerCase();
+		if (t === "point") {
+			if (!isPointLike(value)) throw new Error(`Invalid value for ${context}. Expected Point { x: number, y: number }`);
+			return;
+		}
+		if (t === "line") {
+			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Line { A: number, B: number, C: number }`);
+			const A = value.A, B = value.B, C = value.C;
+			if (!isFiniteNumber(A) || !isFiniteNumber(B) || !isFiniteNumber(C)) throw new Error(`Invalid Line for ${context}. A, B, C must be finite numbers`);
+			return;
+		}
+		if (t === "lseg" || t === "box") {
+			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected ${t.toUpperCase()} { start: Point, end: Point }`);
+			const start = value.start;
+			const end = value.end;
+			if (!isPointLike(start) || !isPointLike(end)) throw new Error(`Invalid ${t} for ${context}. 'start' and 'end' must be Point { x, y }`);
+			return;
+		}
+		if (t === "path") {
+			if (!Array.isArray(value) || value.length < 1) throw new Error(`Invalid value for ${context}. Expected Path [isClosed: boolean, ...points: Point[]]`);
+			const [isClosed, ...points] = value;
+			if (typeof isClosed !== "boolean") throw new Error(`Invalid Path for ${context}. First element must be boolean (isClosed)`);
+			for (let i = 0; i < points.length; i++) if (!isPointLike(points[i])) throw new Error(`Invalid Path for ${context}. Element at index ${i + 1} must be Point { x, y }`);
+			return;
+		}
+		if (t === "polygon") {
+			if (!Array.isArray(value)) throw new Error(`Invalid value for ${context}. Expected Polygon as Point[]`);
+			for (let i = 0; i < value.length; i++) if (!isPointLike(value[i])) throw new Error(`Invalid Polygon for ${context}. Element at index ${i} must be Point { x, y }`);
+			return;
+		}
+		if (t === "circle") {
+			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Circle { center: Point, radius: number }`);
+			const center = value.center;
+			const radius = value.radius;
+			if (!isPointLike(center) || !isFiniteNumber(radius)) throw new Error(`Invalid Circle for ${context}. 'center' must be Point and 'radius' must be finite number`);
+			return;
+		}
 	}
-	if (kind === "range") {
-		validateRangeForColumn(col, value, context);
-		return;
+	function validateRangeForColumn(col, value, context) {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected a range object for type ${col._typname}`);
+		const r = value;
+		const hasLower = Object.prototype.hasOwnProperty.call(r, "lower");
+		const hasUpper = Object.prototype.hasOwnProperty.call(r, "upper");
+		const hasLi = Object.prototype.hasOwnProperty.call(r, "lowerInclusive");
+		const hasUi = Object.prototype.hasOwnProperty.call(r, "upperInclusive");
+		if (!hasLower || !hasUpper || !hasLi || !hasUi) throw new Error(`Invalid range for ${context}. Required properties: lower, upper, lowerInclusive, upperInclusive`);
+		if (typeof r.lowerInclusive !== "boolean" || typeof r.upperInclusive !== "boolean") throw new Error(`Invalid range for ${context}. lowerInclusive and upperInclusive must be boolean`);
+		const inner = expectedRangeInnerKind(col._typname);
+		if (inner === "number") {
+			if (typeof r.lower !== "number" || !Number.isFinite(r.lower)) throw new Error(`Invalid range.lower for ${context}. Expected number for type ${col._typname}`);
+			if (typeof r.upper !== "number" || !Number.isFinite(r.upper)) throw new Error(`Invalid range.upper for ${context}. Expected number for type ${col._typname}`);
+		} else if (inner === "string") {
+			if (typeof r.lower !== "string") throw new Error(`Invalid range.lower for ${context}. Expected string for type ${col._typname}`);
+			if (typeof r.upper !== "string") throw new Error(`Invalid range.upper for ${context}. Expected string for type ${col._typname}`);
+		}
 	}
-	if (kind === "interval") {
-		validateIntervalForColumn(col, value, context);
-		return;
+	function validateIntervalForColumn(col, value, context) {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected an interval object for type ${col._typname}`);
+		const v = value;
+		for (const k of [
+			"y",
+			"m",
+			"d",
+			"h",
+			"i",
+			"s"
+		]) {
+			if (!Object.prototype.hasOwnProperty.call(v, k)) throw new Error(`Invalid interval for ${context}. Missing property '${k}'`);
+			const num = v[k];
+			if (typeof num !== "number" || !Number.isFinite(num)) throw new Error(`Invalid interval.${String(k)} for ${context}. Expected finite number`);
+		}
 	}
-	if (kind === "geom") {
-		validateGeometryForColumn(col, value, context);
-		return;
+	function isValidJsonLike(value) {
+		return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object" && value !== null;
 	}
-}
-function validateComparisonValue(col, key, value, op) {
-	if (value === void 0 || value === null) throw new Error(`Operator ${op} on column ${key} requires a non-null value. Use isnull/notnull for null checks.`);
-	if (col._is_array) {
-		if (!Array.isArray(value)) throw new Error(`Operator ${op} on array column ${key} requires an array value`);
-		for (const [i, v] of value.entries()) validateScalarForColumn(col, v, `column ${key}[${i}]`);
-	} else {
-		if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) throw new Error(`Operator ${op} on scalar column ${key} cannot accept an array value`);
-		validateScalarForColumn(col, value, `column ${key}`);
+	function validateScalarForColumn(col, value, context) {
+		const kind = expectedScalarKind(col._typname);
+		if (kind === "unknown") return;
+		if (kind === "number") {
+			if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid value for ${context}. Expected number for type ${col._typname}, got ${typeof value}`);
+			return;
+		}
+		if (kind === "string") {
+			if (typeof value !== "string") throw new Error(`Invalid value for ${context}. Expected string for type ${col._typname}, got ${typeof value}`);
+			return;
+		}
+		if (kind === "boolean") {
+			if (typeof value !== "boolean") throw new Error(`Invalid value for ${context}. Expected boolean for type ${col._typname}, got ${typeof value}`);
+			return;
+		}
+		if (kind === "json") {
+			if (!isValidJsonLike(value)) throw new Error(`Invalid value for ${context}. Expected JSON-compatible value for type ${col._typname}`);
+			return;
+		}
+		if (kind === "range") {
+			validateRangeForColumn(col, value, context);
+			return;
+		}
+		if (kind === "interval") {
+			validateIntervalForColumn(col, value, context);
+			return;
+		}
+		if (kind === "geom") {
+			validateGeometryForColumn(col, value, context);
+			return;
+		}
 	}
-}
-function validateInArrayValues(col, key, values, op) {
-	if (!col._is_array) {
-		let idx = 0;
-		for (const v of values) {
-			validateScalarForColumn(col, v, `column ${key} (element ${idx})`);
-			idx++;
+	function validateComparisonValue(col, key, value, op) {
+		if (value === void 0 || value === null) throw new Error(`Operator ${op} on column ${key} requires a non-null value. Use isnull/notnull for null checks.`);
+		if (col._is_array) {
+			if (!Array.isArray(value)) throw new Error(`Operator ${op} on array column ${key} requires an array value`);
+			for (const [i, v] of value.entries()) validateScalarForColumn(col, v, `column ${key}[${i}]`);
+		} else {
+			if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) throw new Error(`Operator ${op} on scalar column ${key} cannot accept an array value`);
+			validateScalarForColumn(col, value, `column ${key}`);
 		}
 	}
-}
-function findJoinOn(base, target) {
-	const bc = base.constraints || [];
-	const tc = target.constraints || [];
-	for (const c of bc) if (c.constraint === "foreign" && c.referenced_table === target.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.columns.map((col, i) => ({
-		left: String(col),
-		right: String(c.referenced_columns[i])
-	}));
-	for (const c of tc) if (c.constraint === "foreign" && c.referenced_table === base.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.referenced_columns.map((rcol, i) => ({
-		left: String(rcol),
-		right: String(c.columns[i])
-	}));
-	return null;
-}
-var TableQueryImpl = class {
-	constructor(schema, tableName) {
-		this.schema = schema;
-		this.table = findTable(schema, tableName);
+	function validateInArrayValues(col, key, values, op) {
+		if (!col._is_array) {
+			let idx = 0;
+			for (const v of values) {
+				validateScalarForColumn(col, v, `column ${key} (element ${idx})`);
+				idx++;
+			}
+		}
 	}
-	select(cols) {
-		const table = this.table;
-		const schema = this.schema;
-		const selected = cols && cols.length ? cols : ["*"];
-		const state = {
-			table,
-			selected,
-			where: {},
-			orWhereGroups: [],
-			andOps: [],
-			orOpGroups: [],
-			order: [],
-			limit: void 0,
-			offset: void 0,
-			joins: [],
-			joinSelections: []
-		};
-		return new class {
-			constructor() {
-				this.s = state;
-				this.toSql = () => {
-					const params = {};
-					const type_hints = {};
-					let p = 0;
-					const parts = [];
-					const selectParts = [];
-					if (selected.length === 1 && selected[0] === "*") selectParts.push(`"${table.name}".*`);
-					else {
-						const sel = selected;
-						for (const c of sel) findColumn(table, String(c));
-						selectParts.push(sel.map((c) => `"${table.name}"."${c}"`).join(", "));
-					}
-					for (const js of state.joinSelections) if (js.selected.length === 1 && js.selected[0] === "*") selectParts.push(`"${js.target.name}".*`);
-					else {
-						const cols$1 = js.selected;
-						for (const c of cols$1) findColumn(js.target, String(c));
-						selectParts.push(cols$1.map((c) => `"${js.target.name}"."${c}"`).join(", "));
-					}
-					parts.push(`select ${selectParts.join(", ")} from "${schema.name}"."${table.name}"`);
-					for (const j of state.joins) {
-						const onExpr = j.on.map((p$1) => `"${j.source.name}"."${p$1.left}" = "${j.target.name}"."${p$1.right}"`).join(" and ");
-						parts.push(`${j.type} join "${schema.name}"."${j.target.name}" on ${onExpr}`);
-					}
-					const andParts = [];
-					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`);
-							andParts.push(`"${table.name}"."${key}" is null`);
-						} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
-							validateInArrayValues(col, key, value, "in");
-							andParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
-							params[paramName] = value;
-							addTypeHintForParam(type_hints, paramName, col, value);
-						} else {
-							validateScalarForColumn(col, value, `column ${key}`);
-							andParts.push(`"${table.name}"."${key}" = :${paramName}`);
-							params[paramName] = value;
-							addTypeHintForParam(type_hints, paramName, col, value);
+	function findJoinOn(base, target) {
+		const bc = base.constraints || [];
+		const tc = target.constraints || [];
+		for (const c of bc) if (c.constraint === "foreign" && c.referenced_table === target.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.columns.map((col, i) => ({
+			left: String(col),
+			right: String(c.referenced_columns[i])
+		}));
+		for (const c of tc) if (c.constraint === "foreign" && c.referenced_table === base.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.referenced_columns.map((rcol, i) => ({
+			left: String(rcol),
+			right: String(c.columns[i])
+		}));
+		return null;
+	}
+	var TableQueryImpl = class {
+		constructor(schema, tableName) {
+			this.schema = schema;
+			this.table = findTable(schema, tableName);
+		}
+		select(cols) {
+			const table = this.table;
+			const schema = this.schema;
+			const selected = cols && cols.length ? cols : ["*"];
+			const state = {
+				table,
+				selected,
+				where: {},
+				orWhereGroups: [],
+				andOps: [],
+				orOpGroups: [],
+				order: [],
+				limit: void 0,
+				offset: void 0,
+				joins: [],
+				joinSelections: []
+			};
+			return new class {
+				constructor() {
+					this.s = state;
+					this.toSql = () => {
+						const params = {};
+						const type_hints = {};
+						let p = 0;
+						const parts = [];
+						const selectParts = [];
+						if (selected.length === 1 && selected[0] === "*") selectParts.push(`"${table.name}".*`);
+						else {
+							const sel = selected;
+							for (const c of sel) findColumn(table, String(c));
+							selectParts.push(sel.map((c) => `"${table.name}"."${c}"`).join(", "));
 						}
-					}
-					for (const pred of state.andOps) {
-						const key = String(pred.col);
-						const op = String(pred.op);
-						const col = findColumn(table, key);
-						const qualified = `"${table.name}"."${key}"`;
-						if (op === "isnull" || op === "notnull") {
-							if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
-							andParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
-						} else if (op === "in" || op === "notin") {
-							const val = pred.value;
-							if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
-							validateInArrayValues(col, key, val, op);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							andParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
-							params[paramName] = val;
-							addTypeHintForParam(type_hints, paramName, col, val);
-						} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
-							const val = pred.value;
-							if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
-							andParts.push(`${qualified} ${sqlOp} :${paramName}`);
-							params[paramName] = val;
-							addTypeHintForParam(type_hints, paramName, col, val);
-						} else {
-							const val = pred.value;
-							if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
-							validateComparisonValue(col, key, val, op);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							if (op === "=") andParts.push(`${qualified} = :${paramName}`);
-							else if (op === "!=") andParts.push(`${qualified} <> :${paramName}`);
-							else if (op === "<" || op === "<=" || op === ">" || op === ">=") andParts.push(`${qualified} ${op} :${paramName}`);
-							else throw new Error(`Unsupported operator: ${op}`);
-							params[paramName] = val;
-							addTypeHintForParam(type_hints, paramName, col, val);
+						for (const js of state.joinSelections) if (js.selected.length === 1 && js.selected[0] === "*") selectParts.push(`"${js.target.name}".*`);
+						else {
+							const cols$1 = js.selected;
+							for (const c of cols$1) findColumn(js.target, String(c));
+							selectParts.push(cols$1.map((c) => `"${js.target.name}"."${c}"`).join(", "));
 						}
-					}
-					const orGroupSql = [];
-					for (const group of state.orWhereGroups) {
-						const orParts = [];
-						for (const key in group) {
-							const value = group[key];
+						parts.push(`select ${selectParts.join(", ")} from "${schema.name}"."${table.name}"`);
+						for (const j of state.joins) {
+							const onExpr = j.on.map((p$1) => `"${j.source.name}"."${p$1.left}" = "${j.target.name}"."${p$1.right}"`).join(" and ");
+							parts.push(`${j.type} join "${schema.name}"."${j.target.name}" on ${onExpr}`);
+						}
+						const andParts = [];
+						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`);
-								orParts.push(`"${table.name}"."${key}" is null`);
+								andParts.push(`"${table.name}"."${key}" is null`);
 							} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
 								validateInArrayValues(col, key, value, "in");
-								orParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+								andParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
 								params[paramName] = value;
 								addTypeHintForParam(type_hints, paramName, col, value);
 							} else {
 								validateScalarForColumn(col, value, `column ${key}`);
-								orParts.push(`"${table.name}"."${key}" = :${paramName}`);
+								andParts.push(`"${table.name}"."${key}" = :${paramName}`);
 								params[paramName] = value;
 								addTypeHintForParam(type_hints, paramName, col, value);
 							}
 						}
-						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
-					}
-					for (const group of state.orOpGroups) {
-						const orParts = [];
-						for (const pred of group) {
+						for (const pred of state.andOps) {
 							const key = String(pred.col);
 							const op = String(pred.op);
 							const col = findColumn(table, key);
 							const qualified = `"${table.name}"."${key}"`;
 							if (op === "isnull" || op === "notnull") {
 								if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
-								orParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+								andParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
 							} else if (op === "in" || op === "notin") {
 								const val = pred.value;
 								if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
 								validateInArrayValues(col, key, val, op);
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
-								orParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+								andParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
@@ -1014,7 +1185,7 @@ var TableQueryImpl = class {
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
 								const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
-								orParts.push(`${qualified} ${sqlOp} :${paramName}`);
+								andParts.push(`${qualified} ${sqlOp} :${paramName}`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							} else {
@@ -1023,252 +1194,137 @@ var TableQueryImpl = class {
 								validateComparisonValue(col, key, val, op);
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
-								if (op === "=") orParts.push(`${qualified} = :${paramName}`);
-								else if (op === "!=") orParts.push(`${qualified} <> :${paramName}`);
-								else if (op === "<" || op === "<=" || op === ">" || op === ">=") orParts.push(`${qualified} ${op} :${paramName}`);
+								if (op === "=") andParts.push(`${qualified} = :${paramName}`);
+								else if (op === "!=") andParts.push(`${qualified} <> :${paramName}`);
+								else if (op === "<" || op === "<=" || op === ">" || op === ">=") andParts.push(`${qualified} ${op} :${paramName}`);
 								else throw new Error(`Unsupported operator: ${op}`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							}
 						}
-						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
-					}
-					if (orGroupSql.length) {
-						const andSql = andParts.length ? `(${andParts.join(" and ")})` : "";
-						const orSql = orGroupSql.join(" or ");
-						const full = andSql ? `${andSql} or ${orSql}` : orSql;
-						if (full.trim().length) parts.push("where " + full);
-					} else if (andParts.length) parts.push("where " + andParts.join(" and "));
-					if (state.order.length) {
-						const orders = [];
-						for (const o of state.order) orders.push(`"${table.name}"."${o.col}" ${o.dir}`);
-						parts.push("order by " + orders.join(", "));
-					}
-					if (state.limit !== void 0) parts.push("limit " + state.limit);
-					if (state.offset !== void 0) parts.push("offset " + state.offset);
-					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 orGroupSql = [];
+						for (const group of state.orWhereGroups) {
+							const orParts = [];
+							for (const key in group) {
+								const value = group[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`);
+									orParts.push(`"${table.name}"."${key}" is null`);
+								} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+									validateInArrayValues(col, key, value, "in");
+									orParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+									params[paramName] = value;
+									addTypeHintForParam(type_hints, paramName, col, value);
+								} else {
+									validateScalarForColumn(col, value, `column ${key}`);
+									orParts.push(`"${table.name}"."${key}" = :${paramName}`);
+									params[paramName] = value;
+									addTypeHintForParam(type_hints, paramName, col, value);
+								}
+							}
+							if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+						}
+						for (const group of state.orOpGroups) {
+							const orParts = [];
+							for (const pred of group) {
+								const key = String(pred.col);
+								const op = String(pred.op);
+								const col = findColumn(table, key);
+								const qualified = `"${table.name}"."${key}"`;
+								if (op === "isnull" || op === "notnull") {
+									if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
+									orParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+								} else if (op === "in" || op === "notin") {
+									const val = pred.value;
+									if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
+									validateInArrayValues(col, key, val, op);
+									p += 1;
+									const paramName = `${table.name}_${key}_${p}`;
+									orParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+									params[paramName] = val;
+									addTypeHintForParam(type_hints, paramName, col, val);
+								} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
+									const val = pred.value;
+									if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
+									p += 1;
+									const paramName = `${table.name}_${key}_${p}`;
+									const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
+									orParts.push(`${qualified} ${sqlOp} :${paramName}`);
+									params[paramName] = val;
+									addTypeHintForParam(type_hints, paramName, col, val);
+								} else {
+									const val = pred.value;
+									if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
+									validateComparisonValue(col, key, val, op);
+									p += 1;
+									const paramName = `${table.name}_${key}_${p}`;
+									if (op === "=") orParts.push(`${qualified} = :${paramName}`);
+									else if (op === "!=") orParts.push(`${qualified} <> :${paramName}`);
+									else if (op === "<" || op === "<=" || op === ">" || op === ">=") orParts.push(`${qualified} ${op} :${paramName}`);
+									else throw new Error(`Unsupported operator: ${op}`);
+									params[paramName] = val;
+									addTypeHintForParam(type_hints, paramName, col, val);
+								}
+							}
+							if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+						}
+						if (orGroupSql.length) {
+							const andSql = andParts.length ? `(${andParts.join(" and ")})` : "";
+							const orSql = orGroupSql.join(" or ");
+							const full = andSql ? `${andSql} or ${orSql}` : orSql;
+							if (full.trim().length) parts.push("where " + full);
+						} else if (andParts.length) parts.push("where " + andParts.join(" and "));
+						if (state.order.length) {
+							const orders = [];
+							for (const o of state.order) orders.push(`"${table.name}"."${o.col}" ${o.dir}`);
+							parts.push("order by " + orders.join(", "));
+						}
+						if (state.limit !== void 0) parts.push("limit " + state.limit);
+						if (state.offset !== void 0) parts.push("offset " + state.offset);
+						return {
+							q: parts.join(" "),
+							params: Object.keys(params).length > 0 ? params : void 0,
+							type_hints: Object.keys(type_hints).length ? type_hints : void 0
+						};
 					};
-				};
-			}
-			selectFrom(tableName, cols$1) {
-				const jtName = String(tableName);
-				const join = this.s.joins.find((j) => j.target.name === jtName);
-				if (!join) throw new Error(`selectFrom('${jtName}') requires a prior join('${jtName}') call`);
-				const sel = !cols$1 || cols$1.length === 0 ? ["*"] : cols$1.map(String);
-				if (!(sel.length === 1 && sel[0] === "*")) for (const c of sel) findColumn(join.target, String(c));
-				const existing = this.s.joinSelections.find((js) => js.target.name === jtName);
-				if (existing) {
-					if (existing.selected.includes("*")) return this;
-					if (sel.length === 1 && sel[0] === "*") existing.selected = ["*"];
-					else {
-						const set = new Set(existing.selected);
-						for (const c of sel) set.add(String(c));
-						existing.selected = Array.from(set);
-					}
-				} else this.s.joinSelections.push({
-					target: join.target,
-					selected: sel
-				});
-				return this;
-			}
-			andWhere(where) {
-				for (const k in where) this.s.where[k] = where[k];
-				return this;
-			}
-			/** @deprecated Use andWhere() instead */
-			where(where) {
-				return this.andWhere(where);
-			}
-			orWhere(where) {
-				this.s.orWhereGroups.push(where);
-				return this;
-			}
-			wherePk(pk) {
-				const pkCols = getPrimaryKeyColumns(table);
-				if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
-				if (pkCols.length === 1) {
-					const colName = pkCols[0];
-					const colDef = findColumn(table, colName);
-					if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
-					if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
-					if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
-					validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
-					this.s.where[colName] = pk;
-					return this;
-				} else {
-					if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
-					const obj = pk;
-					for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
-					for (const colName of pkCols) {
-						if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
-						const v = obj[colName];
-						if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
-						if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
-						validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
-						this.s.where[colName] = v;
-					}
-					return this;
 				}
-			}
-			andWhereOp(col, op, ...args) {
-				const value = args[0];
-				this.s.andOps.push({
-					col,
-					op,
-					value
-				});
-				return this;
-			}
-			orWhereOp(col, op, ...args) {
-				const value = args[0];
-				this.s.orOpGroups.push([{
-					col,
-					op,
-					value
-				}]);
-				return this;
-			}
-			andWhereOpGroup(predicates) {
-				const group = predicates.map((p) => ({
-					col: p[0],
-					op: p[1],
-					value: p[2]
-				}));
-				for (const g of group) this.s.andOps.push(g);
-				return this;
-			}
-			orWhereOpGroup(predicates) {
-				const group = predicates.map((p) => ({
-					col: p[0],
-					op: p[1],
-					value: p[2]
-				}));
-				this.s.orOpGroups.push(group);
-				return this;
-			}
-			orderBy(order) {
-				this.s.order = [];
-				const isValidDir = (d) => d === "asc" || d === "desc";
-				if (typeof order === "string") {
-					findColumn(table, String(order));
-					this.s.order.push({
-						col: order,
-						dir: "asc"
-					});
-				} else for (const item of order) {
-					const col = String(item[0]);
-					const dir = String(item[1]);
-					findColumn(table, col);
-					if (!isValidDir(dir)) throw new Error(`Invalid order direction: ${dir}. Allowed: asc | desc`);
-					this.s.order.push({
-						col: item[0],
-						dir
+				selectFrom(tableName, cols$1) {
+					const jtName = String(tableName);
+					const join = this.s.joins.find((j) => j.target.name === jtName);
+					if (!join) throw new Error(`selectFrom('${jtName}') requires a prior join('${jtName}') call`);
+					const sel = !cols$1 || cols$1.length === 0 ? ["*"] : cols$1.map(String);
+					if (!(sel.length === 1 && sel[0] === "*")) for (const c of sel) findColumn(join.target, String(c));
+					const existing = this.s.joinSelections.find((js) => js.target.name === jtName);
+					if (existing) {
+						if (existing.selected.includes("*")) return this;
+						if (sel.length === 1 && sel[0] === "*") existing.selected = ["*"];
+						else {
+							const set = new Set(existing.selected);
+							for (const c of sel) set.add(String(c));
+							existing.selected = Array.from(set);
+						}
+					} else this.s.joinSelections.push({
+						target: join.target,
+						selected: sel
 					});
+					return this;
 				}
-				return this;
-			}
-			limit(n) {
-				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid limit: ${n}. Limit must be a non-negative integer`);
-				this.s.limit = n;
-				return this;
-			}
-			offset(n) {
-				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid offset: ${n}. Offset must be a non-negative integer`);
-				this.s.offset = n;
-				return this;
-			}
-			join(tableName, type = "inner") {
-				const target = findTable(schema, String(tableName));
-				const sources = [];
-				for (let i = this.s.joins.length - 1; i >= 0; i--) {
-					const src = this.s.joins[i].target;
-					if (!sources.some((s) => s.name === src.name)) sources.push(src);
-				}
-				if (!sources.some((s) => s.name === table.name)) sources.push(table);
-				let pickedSource = null;
-				let pairs = null;
-				for (const src of sources) {
-					const p = findJoinOn(src, target);
-					if (p && p.length) {
-						pickedSource = src;
-						pairs = p;
-						break;
-					}
-				}
-				if (!pairs || !pickedSource) {
-					const candidates = sources.map((s) => s.name).join(", ");
-					throw new Error(`No foreign key relation found between any of [${candidates}] and ${target.name}`);
+				andWhere(where) {
+					for (const k in where) this.s.where[k] = where[k];
+					return this;
 				}
-				const jt = String(type);
-				if (jt !== "inner" && jt !== "left" && jt !== "right" && jt !== "full") throw new Error(`Invalid join type: ${jt}. Allowed: inner | left | right | full`);
-				this.s.joins.push({
-					type: jt,
-					source: pickedSource,
-					target,
-					on: pairs
-				});
-				return this;
-			}
-		}();
-	}
-	insert(values) {
-		const table = this.table;
-		const schema = this.schema;
-		const state = {
-			values,
-			returning: []
-		};
-		return new class {
-			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);
+				/** @deprecated Use andWhere() instead */
+				where(where) {
+					return this.andWhere(where);
 				}
-				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;
-			}
-		}();
-	}
-	update(values) {
-		const table = this.table;
-		const schema = this.schema;
-		const state = {
-			values,
-			where: {},
-			returning: []
-		};
-		return new class {
-			constructor() {
-				this.where = (w) => {
-					for (const k in w) state.where[k] = w[k];
+				orWhere(where) {
+					this.s.orWhereGroups.push(where);
 					return this;
-				};
-				this.wherePk = (pk) => {
+				}
+				wherePk(pk) {
 					const pkCols = getPrimaryKeyColumns(table);
 					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
 					if (pkCols.length === 1) {
@@ -1278,7 +1334,8 @@ var TableQueryImpl = class {
 						if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
 						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
 						validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
-						state.where[colName] = pk;
+						this.s.where[colName] = pk;
+						return this;
 					} else {
 						if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
 						const obj = pk;
@@ -1289,146 +1346,884 @@ var TableQueryImpl = class {
 							if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
 							if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
 							validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
-							state.where[colName] = v;
+							this.s.where[colName] = v;
 						}
+						return this;
 					}
+				}
+				andWhereOp(col, op, ...args) {
+					const value = args[0];
+					this.s.andOps.push({
+						col,
+						op,
+						value
+					});
 					return this;
-				};
-			}
-			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);
+				orWhereOp(col, op, ...args) {
+					const value = args[0];
+					this.s.orOpGroups.push([{
+						col,
+						op,
+						value
+					}]);
+					return this;
+				}
+				andWhereOpGroup(predicates) {
+					const group = predicates.map((p) => ({
+						col: p[0],
+						op: p[1],
+						value: p[2]
+					}));
+					for (const g of group) this.s.andOps.push(g);
+					return this;
+				}
+				orWhereOpGroup(predicates) {
+					const group = predicates.map((p) => ({
+						col: p[0],
+						op: p[1],
+						value: p[2]
+					}));
+					this.s.orOpGroups.push(group);
+					return this;
+				}
+				orderBy(order) {
+					this.s.order = [];
+					const isValidDir = (d) => d === "asc" || d === "desc";
+					if (typeof order === "string") {
+						findColumn(table, String(order));
+						this.s.order.push({
+							col: order,
+							dir: "asc"
+						});
+					} else for (const item of order) {
+						const col = String(item[0]);
+						const dir = String(item[1]);
+						findColumn(table, col);
+						if (!isValidDir(dir)) throw new Error(`Invalid order direction: ${dir}. Allowed: asc | desc`);
+						this.s.order.push({
+							col: item[0],
+							dir
+						});
 					}
+					return this;
 				}
-				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;
-			}
-		}();
-	}
-	delete() {
-		const table = this.table;
-		const schema = this.schema;
-		const state = {
-			where: {},
-			returning: []
-		};
-		return new class {
-			constructor() {
-				this.where = (w) => {
-					for (const k in w) state.where[k] = w[k];
+				limit(n) {
+					if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid limit: ${n}. Limit must be a non-negative integer`);
+					this.s.limit = n;
 					return this;
-				};
-				this.wherePk = (pk) => {
-					const pkCols = getPrimaryKeyColumns(table);
-					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
-					if (pkCols.length === 1) {
-						const col = pkCols[0];
-						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${col}`);
-						state.where[col] = pk;
-					} else {
-						if (!isPlainObject(pk)) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
-						const obj = pk;
-						for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
-						for (const col of pkCols) {
-							if (!(col in obj)) throw new Error(`wherePk missing key '${col}'. Required keys: ${pkCols.join(", ")}`);
-							state.where[col] = obj[col];
+				}
+				offset(n) {
+					if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid offset: ${n}. Offset must be a non-negative integer`);
+					this.s.offset = n;
+					return this;
+				}
+				join(tableName, type = "inner") {
+					const target = findTable(schema, String(tableName));
+					const sources = [];
+					for (let i = this.s.joins.length - 1; i >= 0; i--) {
+						const src = this.s.joins[i].target;
+						if (!sources.some((s) => s.name === src.name)) sources.push(src);
+					}
+					if (!sources.some((s) => s.name === table.name)) sources.push(table);
+					let pickedSource = null;
+					let pairs = null;
+					for (const src of sources) {
+						const p = findJoinOn(src, target);
+						if (p && p.length) {
+							pickedSource = src;
+							pairs = p;
+							break;
 						}
 					}
+					if (!pairs || !pickedSource) {
+						const candidates = sources.map((s) => s.name).join(", ");
+						throw new Error(`No foreign key relation found between any of [${candidates}] and ${target.name}`);
+					}
+					const jt = String(type);
+					if (jt !== "inner" && jt !== "left" && jt !== "right" && jt !== "full") throw new Error(`Invalid join type: ${jt}. Allowed: inner | left | right | full`);
+					this.s.joins.push({
+						type: jt,
+						source: pickedSource,
+						target,
+						on: pairs
+					});
 					return this;
-				};
-			}
-			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})`);
+				}
+			}();
+		}
+		insert(values) {
+			const table = this.table;
+			const schema = this.schema;
+			const state = {
+				values,
+				returning: []
+			};
+			return new class {
+				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);
-					} else {
-						validateScalarForColumn(col, value, `column ${key}`);
-						whereClauses.push(`"${key}" = :${paramName}`);
+					}
+					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;
+				}
+			}();
+		}
+		update(values) {
+			const table = this.table;
+			const schema = this.schema;
+			const state = {
+				values,
+				where: {},
+				returning: []
+			};
+			return new class {
+				constructor() {
+					this.where = (w) => {
+						for (const k in w) state.where[k] = w[k];
+						return this;
+					};
+					this.wherePk = (pk) => {
+						const pkCols = getPrimaryKeyColumns(table);
+						if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+						if (pkCols.length === 1) {
+							const colName = pkCols[0];
+							const colDef = findColumn(table, colName);
+							if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
+							if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
+							if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
+							validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
+							state.where[colName] = pk;
+						} else {
+							if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+							const obj = pk;
+							for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+							for (const colName of pkCols) {
+								if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
+								const v = obj[colName];
+								if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
+								if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
+								validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
+								state.where[colName] = v;
+							}
+						}
+						return this;
+					};
+				}
+				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 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;
 				}
-				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;
+			}();
+		}
+		delete() {
+			const table = this.table;
+			const schema = this.schema;
+			const state = {
+				where: {},
+				returning: []
+			};
+			return new class {
+				constructor() {
+					this.where = (w) => {
+						for (const k in w) state.where[k] = w[k];
+						return this;
+					};
+					this.wherePk = (pk) => {
+						const pkCols = getPrimaryKeyColumns(table);
+						if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+						if (pkCols.length === 1) {
+							const col = pkCols[0];
+							if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${col}`);
+							state.where[col] = pk;
+						} else {
+							if (!isPlainObject(pk)) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+							const obj = pk;
+							for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+							for (const col of pkCols) {
+								if (!(col in obj)) throw new Error(`wherePk missing key '${col}'. Required keys: ${pkCols.join(", ")}`);
+								state.where[col] = obj[col];
+							}
+						}
+						return this;
+					};
+				}
+				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(", "));
+					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;
+				}
+			}();
+		}
+	};
+	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)
 			}
-		}();
+		};
 	}
-};
-function createSqlBuilder(schema) {
-	return { table: (name) => new TableQueryImpl(schema, String(name)) };
-}
 
 //#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;
@@ -1440,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;
 });