@centia-io/sdk 0.2.1 → 0.2.3

package/dist/centia-io-sdk-node.js.map

@@ -1 +1 @@
-{"version":3,"file":"centia-io-sdk-node.js","names":["configstoreInstance: any | null","setChain: Promise<void>","Configstore: any","result: StoredCredentials","filePath: string","e: any"],"sources":["../src/auth/configstoreTokenStore.ts"],"sourcesContent":["/**\r\n * @author     Martin Høgh <mh@mapcentia.com>\r\n * @copyright  2013-2026 MapCentia ApS\r\n * @license    https://opensource.org/license/mit  The MIT License\r\n *\r\n */\r\n\r\nimport type { StoredCredentials, TokenStore } from './types'\r\n\r\nconst LOCK_RETRIES = 5\r\nconst LOCK_RETRY_MIN_MS = 100\r\nconst LOCK_RETRY_MAX_MS = 500\r\nconst LOCK_STALE_MS = 10_000\r\n\r\n/**\r\n * Build a Node-only file-backed {@link TokenStore} that persists OAuth\r\n * credentials at `~/.config/configstore/<name>.json` (or\r\n * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process\r\n * and cross-process write safety.\r\n *\r\n * **Shared-state intent.** The `name` is the file name on disk. Two processes\r\n * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the\r\n * same on-disk credentials and therefore the same login session. The default\r\n * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time\r\n * `gc2 login` is observable to every process that calls\r\n * `createConfigstoreTokenStore()` with no argument. Pass a different name\r\n * to isolate.\r\n *\r\n * **In-process correctness.** A serial promise chain on `set()` ensures\r\n * concurrent same-process calls do not race on the shared configstore cache.\r\n *\r\n * **Cross-process correctness.** `proper-lockfile` serializes the\r\n * read-merge-write critical section across processes so two simultaneous\r\n * `set()` calls from different processes cannot corrupt the file.\r\n *\r\n * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`\r\n * out of browser bundles even when this module is imported through the SDK\r\n * barrel. Calling this function in a browser environment will fail at\r\n * runtime when the deferred `await import('configstore')` cannot resolve.\r\n *\r\n * @param name - configstore file name (without `.json`). Default `'gc2-env'`\r\n *               matches `gc2-cli`'s configstore so credentials are shared.\r\n * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.\r\n */\r\nexport function createConfigstoreTokenStore(name = 'gc2-env'): TokenStore {\r\n    let configstoreInstance: any | null = null\r\n    let setChain: Promise<void> = Promise.resolve()\r\n\r\n    async function getConfigstore(): Promise<any> {\r\n        if (configstoreInstance) return configstoreInstance\r\n        const mod = await import('configstore')\r\n        const Configstore: any = (mod as any).default ?? mod\r\n        const { homedir } = await import('node:os')\r\n        const { join } = await import('node:path')\r\n        // Resolve XDG_CONFIG_HOME at call time (not at module-load time):\r\n        // configstore@7's transitive xdg-basedir snapshots the env var when\r\n        // first imported, which would ignore per-test mutations and (more\r\n        // importantly) couple our path to xdg-basedir's caching across\r\n        // process lifetimes. Computing configPath ourselves keeps the\r\n        // SDK's storage location stable regardless of dep version churn.\r\n        const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config')\r\n        const configPath = join(xdgConfig, 'configstore', `${name}.json`)\r\n        configstoreInstance = new Configstore(name, undefined, { configPath })\r\n        return configstoreInstance\r\n    }\r\n\r\n    async function getLockfile(): Promise<typeof import('proper-lockfile')> {\r\n        const mod = await import('proper-lockfile')\r\n        return ((mod as any).default ?? mod) as typeof import('proper-lockfile')\r\n    }\r\n\r\n    function readAll(cs: any): StoredCredentials {\r\n        const result: StoredCredentials = {}\r\n        const token = cs.get('token')\r\n        const refresh_token = cs.get('refresh_token')\r\n        const host = cs.get('host')\r\n        if (token !== undefined) result.token = token\r\n        if (refresh_token !== undefined) result.refresh_token = refresh_token\r\n        if (host !== undefined) result.host = host\r\n        return result\r\n    }\r\n\r\n    async function doLockedSet(patch: Partial<StoredCredentials>): Promise<void> {\r\n        const cs = await getConfigstore()\r\n        const lockfile = await getLockfile()\r\n        const filePath: string = cs.path\r\n\r\n        // Ensure the file (and its directory) exist so proper-lockfile has\r\n        // something to anchor on. `wx` is atomic create-if-not-exists, so this\r\n        // is safe even if another process is racing to create the same file.\r\n        const { mkdirSync, writeFileSync } = await import('node:fs')\r\n        const { dirname } = await import('node:path')\r\n        try {\r\n            mkdirSync(dirname(filePath), { recursive: true })\r\n            writeFileSync(filePath, '{}', { flag: 'wx' })\r\n        } catch (e: any) {\r\n            if (e?.code !== 'EEXIST') throw e\r\n        }\r\n\r\n        // realpath:false skips symlink resolution. configstore returns an\r\n        // already-absolute path, and resolving symlinks would force an extra\r\n        // stat (and breaks on macOS test tmpdirs which are symlinks).\r\n        const release = await lockfile.lock(filePath, {\r\n            retries: {\r\n                retries: LOCK_RETRIES,\r\n                minTimeout: LOCK_RETRY_MIN_MS,\r\n                maxTimeout: LOCK_RETRY_MAX_MS,\r\n                factor: 2,\r\n            },\r\n            stale: LOCK_STALE_MS,\r\n            realpath: false,\r\n        })\r\n\r\n        try {\r\n            // Force configstore to re-read the on-disk state so we merge\r\n            // against the latest cross-process value, not a stale cache.\r\n            configstoreInstance = null\r\n            const fresh = await getConfigstore()\r\n            const merged: StoredCredentials = { ...readAll(fresh), ...patch }\r\n            ;(fresh as any).all = merged\r\n        } finally {\r\n            await release()\r\n        }\r\n    }\r\n\r\n    return {\r\n        async get(): Promise<StoredCredentials> {\r\n            const cs = await getConfigstore()\r\n            return readAll(cs)\r\n        },\r\n\r\n        async set(patch: Partial<StoredCredentials>): Promise<void> {\r\n            const next = setChain.then(() => doLockedSet(patch))\r\n            // Don't poison the chain on a rejection; the original error still\r\n            // propagates via `next` to the caller.\r\n            setChain = next.catch(() => {})\r\n            return next\r\n        },\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAM,eAAe;AACrB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAC1B,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,SAAgB,4BAA4B,OAAO,WAAuB;CACtE,IAAIA,sBAAkC;CACtC,IAAIC,WAA0B,QAAQ,SAAS;CAE/C,eAAe,iBAA+B;;AAC1C,MAAI,oBAAqB,QAAO;EAChC,MAAM,MAAM,MAAM,OAAO;EACzB,MAAMC,0BAAoB,IAAY,sDAAW;EACjD,MAAM,EAAE,YAAY,MAAM,OAAO;EACjC,MAAM,EAAE,SAAS,MAAM,OAAO;AAS9B,wBAAsB,IAAI,YAAY,MAAM,QAAW,EAAE,YADtC,KADD,QAAQ,IAAI,mBAAmB,KAAK,SAAS,EAAE,UAAU,EACxC,eAAe,GAAG,KAAK,OAAO,EACI,CAAC;AACtE,SAAO;;CAGX,eAAe,cAAyD;;EACpE,MAAM,MAAM,MAAM,OAAO;AACzB,sBAAS,IAAY,wDAAW;;CAGpC,SAAS,QAAQ,IAA4B;EACzC,MAAMC,SAA4B,EAAE;EACpC,MAAM,QAAQ,GAAG,IAAI,QAAQ;EAC7B,MAAM,gBAAgB,GAAG,IAAI,gBAAgB;EAC7C,MAAM,OAAO,GAAG,IAAI,OAAO;AAC3B,MAAI,UAAU,OAAW,QAAO,QAAQ;AACxC,MAAI,kBAAkB,OAAW,QAAO,gBAAgB;AACxD,MAAI,SAAS,OAAW,QAAO,OAAO;AACtC,SAAO;;CAGX,eAAe,YAAY,OAAkD;EACzE,MAAM,KAAK,MAAM,gBAAgB;EACjC,MAAM,WAAW,MAAM,aAAa;EACpC,MAAMC,WAAmB,GAAG;EAK5B,MAAM,EAAE,WAAW,kBAAkB,MAAM,OAAO;EAClD,MAAM,EAAE,YAAY,MAAM,OAAO;AACjC,MAAI;AACA,aAAU,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACjD,iBAAc,UAAU,MAAM,EAAE,MAAM,MAAM,CAAC;WACxCC,GAAQ;AACb,8CAAI,EAAG,UAAS,SAAU,OAAM;;EAMpC,MAAM,UAAU,MAAM,SAAS,KAAK,UAAU;GAC1C,SAAS;IACL,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,QAAQ;IACX;GACD,OAAO;GACP,UAAU;GACb,CAAC;AAEF,MAAI;AAGA,yBAAsB;GACtB,MAAM,QAAQ,MAAM,gBAAgB;AAEnC,GAAC,MAAc,wCADuB,QAAQ,MAAM,GAAK;YAEpD;AACN,SAAM,SAAS;;;AAIvB,QAAO;EACH,MAAM,MAAkC;AAEpC,UAAO,QADI,MAAM,gBAAgB,CACf;;EAGtB,MAAM,IAAI,OAAkD;GACxD,MAAM,OAAO,SAAS,WAAW,YAAY,MAAM,CAAC;AAGpD,cAAW,KAAK,YAAY,GAAG;AAC/B,UAAO;;EAEd"}
+{"version":3,"file":"centia-io-sdk-node.js","names":["configstoreInstance: any | null","setChain: Promise<void>","Configstore: any","result: StoredCredentials","filePath: string","e: any"],"sources":["../src/auth/configstoreTokenStore.ts"],"sourcesContent":["/**\n * @author     Martin Høgh <mh@mapcentia.com>\n * @copyright  2013-2026 MapCentia ApS\n * @license    https://opensource.org/license/mit  The MIT License\n *\n */\n\nimport type { StoredCredentials, TokenStore } from './types'\n\nconst LOCK_RETRIES = 5\nconst LOCK_RETRY_MIN_MS = 100\nconst LOCK_RETRY_MAX_MS = 500\nconst LOCK_STALE_MS = 10_000\n\n/**\n * Build a Node-only file-backed {@link TokenStore} that persists OAuth\n * credentials at `~/.config/configstore/<name>.json` (or\n * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process\n * and cross-process write safety.\n *\n * **Shared-state intent.** The `name` is the file name on disk. Two processes\n * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the\n * same on-disk credentials and therefore the same login session. The default\n * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time\n * `gc2 login` is observable to every process that calls\n * `createConfigstoreTokenStore()` with no argument. Pass a different name\n * to isolate.\n *\n * **In-process correctness.** A serial promise chain on `set()` ensures\n * concurrent same-process calls do not race on the shared configstore cache.\n *\n * **Cross-process correctness.** `proper-lockfile` serializes the\n * read-merge-write critical section across processes so two simultaneous\n * `set()` calls from different processes cannot corrupt the file.\n *\n * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`\n * out of browser bundles even when this module is imported through the SDK\n * barrel. Calling this function in a browser environment will fail at\n * runtime when the deferred `await import('configstore')` cannot resolve.\n *\n * @param name - configstore file name (without `.json`). Default `'gc2-env'`\n *               matches `gc2-cli`'s configstore so credentials are shared.\n * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.\n */\nexport function createConfigstoreTokenStore(name = 'gc2-env'): TokenStore {\n    let configstoreInstance: any | null = null\n    let setChain: Promise<void> = Promise.resolve()\n\n    async function getConfigstore(): Promise<any> {\n        if (configstoreInstance) return configstoreInstance\n        const mod = await import('configstore')\n        const Configstore: any = (mod as any).default ?? mod\n        const { homedir } = await import('node:os')\n        const { join } = await import('node:path')\n        // Resolve XDG_CONFIG_HOME at call time (not at module-load time):\n        // configstore@7's transitive xdg-basedir snapshots the env var when\n        // first imported, which would ignore per-test mutations and (more\n        // importantly) couple our path to xdg-basedir's caching across\n        // process lifetimes. Computing configPath ourselves keeps the\n        // SDK's storage location stable regardless of dep version churn.\n        const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config')\n        const configPath = join(xdgConfig, 'configstore', `${name}.json`)\n        configstoreInstance = new Configstore(name, undefined, { configPath })\n        return configstoreInstance\n    }\n\n    async function getLockfile(): Promise<typeof import('proper-lockfile')> {\n        const mod = await import('proper-lockfile')\n        return ((mod as any).default ?? mod) as typeof import('proper-lockfile')\n    }\n\n    function readAll(cs: any): StoredCredentials {\n        const result: StoredCredentials = {}\n        const token = cs.get('token')\n        const refresh_token = cs.get('refresh_token')\n        const host = cs.get('host')\n        if (token !== undefined) result.token = token\n        if (refresh_token !== undefined) result.refresh_token = refresh_token\n        if (host !== undefined) result.host = host\n        return result\n    }\n\n    async function doLockedSet(patch: Partial<StoredCredentials>): Promise<void> {\n        const cs = await getConfigstore()\n        const lockfile = await getLockfile()\n        const filePath: string = cs.path\n\n        // Ensure the file (and its directory) exist so proper-lockfile has\n        // something to anchor on. `wx` is atomic create-if-not-exists, so this\n        // is safe even if another process is racing to create the same file.\n        const { mkdirSync, writeFileSync } = await import('node:fs')\n        const { dirname } = await import('node:path')\n        try {\n            mkdirSync(dirname(filePath), { recursive: true })\n            writeFileSync(filePath, '{}', { flag: 'wx' })\n        } catch (e: any) {\n            if (e?.code !== 'EEXIST') throw e\n        }\n\n        // realpath:false skips symlink resolution. configstore returns an\n        // already-absolute path, and resolving symlinks would force an extra\n        // stat (and breaks on macOS test tmpdirs which are symlinks).\n        const release = await lockfile.lock(filePath, {\n            retries: {\n                retries: LOCK_RETRIES,\n                minTimeout: LOCK_RETRY_MIN_MS,\n                maxTimeout: LOCK_RETRY_MAX_MS,\n                factor: 2,\n            },\n            stale: LOCK_STALE_MS,\n            realpath: false,\n        })\n\n        try {\n            // Force configstore to re-read the on-disk state so we merge\n            // against the latest cross-process value, not a stale cache.\n            configstoreInstance = null\n            const fresh = await getConfigstore()\n            const merged: StoredCredentials = { ...readAll(fresh), ...patch }\n            ;(fresh as any).all = merged\n        } finally {\n            await release()\n        }\n    }\n\n    return {\n        async get(): Promise<StoredCredentials> {\n            const cs = await getConfigstore()\n            return readAll(cs)\n        },\n\n        async set(patch: Partial<StoredCredentials>): Promise<void> {\n            const next = setChain.then(() => doLockedSet(patch))\n            // Don't poison the chain on a rejection; the original error still\n            // propagates via `next` to the caller.\n            setChain = next.catch(() => {})\n            return next\n        },\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAM,eAAe;AACrB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAC1B,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,SAAgB,4BAA4B,OAAO,WAAuB;CACtE,IAAIA,sBAAkC;CACtC,IAAIC,WAA0B,QAAQ,SAAS;CAE/C,eAAe,iBAA+B;;AAC1C,MAAI,oBAAqB,QAAO;EAChC,MAAM,MAAM,MAAM,OAAO;EACzB,MAAMC,0BAAoB,IAAY,sDAAW;EACjD,MAAM,EAAE,YAAY,MAAM,OAAO;EACjC,MAAM,EAAE,SAAS,MAAM,OAAO;AAS9B,wBAAsB,IAAI,YAAY,MAAM,QAAW,EAAE,YADtC,KADD,QAAQ,IAAI,mBAAmB,KAAK,SAAS,EAAE,UAAU,EACxC,eAAe,GAAG,KAAK,OAAO,EACI,CAAC;AACtE,SAAO;;CAGX,eAAe,cAAyD;;EACpE,MAAM,MAAM,MAAM,OAAO;AACzB,sBAAS,IAAY,wDAAW;;CAGpC,SAAS,QAAQ,IAA4B;EACzC,MAAMC,SAA4B,EAAE;EACpC,MAAM,QAAQ,GAAG,IAAI,QAAQ;EAC7B,MAAM,gBAAgB,GAAG,IAAI,gBAAgB;EAC7C,MAAM,OAAO,GAAG,IAAI,OAAO;AAC3B,MAAI,UAAU,OAAW,QAAO,QAAQ;AACxC,MAAI,kBAAkB,OAAW,QAAO,gBAAgB;AACxD,MAAI,SAAS,OAAW,QAAO,OAAO;AACtC,SAAO;;CAGX,eAAe,YAAY,OAAkD;EACzE,MAAM,KAAK,MAAM,gBAAgB;EACjC,MAAM,WAAW,MAAM,aAAa;EACpC,MAAMC,WAAmB,GAAG;EAK5B,MAAM,EAAE,WAAW,kBAAkB,MAAM,OAAO;EAClD,MAAM,EAAE,YAAY,MAAM,OAAO;AACjC,MAAI;AACA,aAAU,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACjD,iBAAc,UAAU,MAAM,EAAE,MAAM,MAAM,CAAC;WACxCC,GAAQ;AACb,8CAAI,EAAG,UAAS,SAAU,OAAM;;EAMpC,MAAM,UAAU,MAAM,SAAS,KAAK,UAAU;GAC1C,SAAS;IACL,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,QAAQ;IACX;GACD,OAAO;GACP,UAAU;GACb,CAAC;AAEF,MAAI;AAGA,yBAAsB;GACtB,MAAM,QAAQ,MAAM,gBAAgB;AAEnC,GAAC,MAAc,wCADuB,QAAQ,MAAM,GAAK;YAEpD;AACN,SAAM,SAAS;;;AAIvB,QAAO;EACH,MAAM,MAAkC;AAEpC,UAAO,QADI,MAAM,gBAAgB,CACf;;EAGtB,MAAM,IAAI,OAAkD;GACxD,MAAM,OAAO,SAAS,WAAW,YAAY,MAAM,CAAC;AAGpD,cAAW,KAAK,YAAY,GAAG;AAC/B,UAAO;;EAEd"}

package/dist/centia-io-sdk.cjs

@@ -2352,6 +2352,169 @@ var Rules = class {
 	}
 };
 
+//#endregion
+//#region src/provisioning/Layers.ts
+var Layers = class {
+	constructor(client) {
+		this.client = client;
+	}
+	layerPath(layer) {
+		return `api/v4/layers/${encodeURIComponent(layer)}`;
+	}
+	classPath(layer, classId) {
+		return `${this.layerPath(layer)}/classes/${encodeURIComponent(classId)}`;
+	}
+	async getLayer(layer, opts) {
+		var _this = this;
+		const path = layer ? _this.layerPath(layer) : "api/v4/layers";
+		const query = {};
+		if (opts === null || opts === void 0 ? void 0 : opts.namesOnly) query.namesOnly = "true";
+		return _this.client.request({
+			path,
+			method: "GET",
+			query: Object.keys(query).length > 0 ? query : void 0
+		});
+	}
+	/** Configure existing layer(s): set properties and replace classes. */
+	async postLayer(body) {
+		var _this2 = this;
+		var _res$getHeader;
+		return { location: (_res$getHeader = (await _this2.client.requestFull({
+			path: "api/v4/layers",
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader !== void 0 ? _res$getHeader : "" };
+	}
+	/** Update layer properties (key-merge on the def JSON). */
+	async patchLayer(layer, body) {
+		var _this3 = this;
+		var _res$getHeader2;
+		return { location: (_res$getHeader2 = (await _this3.client.requestFull({
+			path: _this3.layerPath(layer),
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader2 !== void 0 ? _res$getHeader2 : "" };
+	}
+	async getLayerClass(layer, classId) {
+		var _this4 = this;
+		const path = classId != null ? _this4.classPath(layer, classId) : `${_this4.layerPath(layer)}/classes`;
+		return _this4.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postLayerClass(layer, body) {
+		var _this5 = this;
+		var _res$getHeader3;
+		return { location: (_res$getHeader3 = (await _this5.client.requestFull({
+			path: `${_this5.layerPath(layer)}/classes`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader3 !== void 0 ? _res$getHeader3 : "" };
+	}
+	/** Update a class (key-merge). Styles/labels are managed via their own methods. */
+	async patchLayerClass(layer, classId, body) {
+		var _this6 = this;
+		var _res$getHeader4;
+		return { location: (_res$getHeader4 = (await _this6.client.requestFull({
+			path: _this6.classPath(layer, classId),
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader4 !== void 0 ? _res$getHeader4 : "" };
+	}
+	/** Delete class(es). `classId` may be a comma-separated list of ids. */
+	async deleteLayerClass(layer, classId) {
+		var _this7 = this;
+		await _this7.client.request({
+			path: _this7.classPath(layer, classId),
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	async getStyle(layer, classId, styleId) {
+		var _this8 = this;
+		const base = `${_this8.classPath(layer, classId)}/styles`;
+		const path = styleId != null ? `${base}/${encodeURIComponent(styleId)}` : base;
+		return _this8.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postStyle(layer, classId, body) {
+		var _this9 = this;
+		var _res$getHeader5;
+		return { location: (_res$getHeader5 = (await _this9.client.requestFull({
+			path: `${_this9.classPath(layer, classId)}/styles`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader5 !== void 0 ? _res$getHeader5 : "" };
+	}
+	/** Update a style (key-merge). */
+	async patchStyle(layer, classId, styleId, body) {
+		var _this10 = this;
+		var _res$getHeader6;
+		return { location: (_res$getHeader6 = (await _this10.client.requestFull({
+			path: `${_this10.classPath(layer, classId)}/styles/${encodeURIComponent(styleId)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader6 !== void 0 ? _res$getHeader6 : "" };
+	}
+	/** Delete style(s). `styleId` may be a comma-separated list of ids. */
+	async deleteStyle(layer, classId, styleId) {
+		var _this11 = this;
+		await _this11.client.request({
+			path: `${_this11.classPath(layer, classId)}/styles/${encodeURIComponent(styleId)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	async getLabel(layer, classId, labelId) {
+		var _this12 = this;
+		const base = `${_this12.classPath(layer, classId)}/labels`;
+		const path = labelId != null ? `${base}/${encodeURIComponent(labelId)}` : base;
+		return _this12.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postLabel(layer, classId, body) {
+		var _this13 = this;
+		var _res$getHeader7;
+		return { location: (_res$getHeader7 = (await _this13.client.requestFull({
+			path: `${_this13.classPath(layer, classId)}/labels`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader7 !== void 0 ? _res$getHeader7 : "" };
+	}
+	/** Update a label (key-merge). */
+	async patchLabel(layer, classId, labelId, body) {
+		var _this14 = this;
+		var _res$getHeader8;
+		return { location: (_res$getHeader8 = (await _this14.client.requestFull({
+			path: `${_this14.classPath(layer, classId)}/labels/${encodeURIComponent(labelId)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader8 !== void 0 ? _res$getHeader8 : "" };
+	}
+	/** Delete label(s). `labelId` may be a comma-separated list of ids. */
+	async deleteLabel(layer, classId, labelId) {
+		var _this15 = this;
+		await _this15.client.request({
+			path: `${_this15.classPath(layer, classId)}/labels/${encodeURIComponent(labelId)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+};
+
 //#endregion
 //#region src/provisioning/Privileges.ts
 var Privileges = class {
@@ -2525,11 +2688,14 @@ var MetadataWrite = class {
 		this.client = client;
 	}
 	async patchMetaData(body) {
-		return this.client.request({
+		var _this = this;
+		var _res$getHeader;
+		return { location: (_res$getHeader = (await _this.client.requestFull({
 			path: "api/v4/meta",
 			method: "PATCH",
-			body
-		});
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader !== void 0 ? _res$getHeader : "" };
 	}
 };
 
@@ -2651,6 +2817,7 @@ function createCentiaAdminClient(config) {
 			users: new ProvisioningUsers(http),
 			clients: new ProvisioningClients(http),
 			rules: new Rules(http),
+			layers: new Layers(http),
 			privileges: new Privileges(http),
 			rpcMethods: new RpcMethods(http),
 			functions: new Functions(http),
@@ -2662,6 +2829,140 @@ function createCentiaAdminClient(config) {
 	};
 }
 
+//#endregion
+//#region src/ogc/Ows.ts
+function toQuery$1(params) {
+	if (!params) return void 0;
+	const query = {};
+	for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) query[key] = String(value);
+	return Object.keys(query).length > 0 ? query : void 0;
+}
+/**
+* OWS (WMS/WFS/UTFGRID) endpoint wrapper.
+*
+* Token-authenticated clients use `getOws`/`postOws`; anonymous and HTTP-Basic
+* clients use the `...NoToken` variants, which include the database in the path.
+*
+* Responses are streamed from the backend and returned as text (XML) or, for
+* JSON responses such as UTFGRID, as parsed JSON. Binary responses (e.g. WMS
+* GetMap images) are not supported by this wrapper — request those directly.
+*/
+var Ows = class {
+	constructor(client) {
+		this.client = client;
+	}
+	/** Token-authenticated OWS GET (WMS/WFS/UTFGRID). */
+	async getOws(schema, params) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}`,
+			method: "GET",
+			query: toQuery$1(params),
+			accept: "*/*"
+		});
+	}
+	/** Token-authenticated OWS POST (WFS XML). */
+	async postOws(schema, xml) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}`,
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "*/*"
+		});
+	}
+	/** Anonymous/HTTP-Basic OWS GET (WMS/WFS/UTFGRID). */
+	async getOwsNoToken(schema, database, params) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`,
+			method: "GET",
+			query: toQuery$1(params),
+			accept: "*/*"
+		});
+	}
+	/** Anonymous/HTTP-Basic OWS POST (WFS XML). */
+	async postOwsNoToken(schema, database, xml) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`,
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "*/*"
+		});
+	}
+};
+
+//#endregion
+//#region src/ogc/Wfs.ts
+function wfsPath(base, options) {
+	let path = base;
+	if ((options === null || options === void 0 ? void 0 : options.timeSlice) != null && options.srs == null) throw new Error("timeSlice requires srs to be set");
+	if ((options === null || options === void 0 ? void 0 : options.srs) != null) {
+		path += `/srs/${encodeURIComponent(options.srs)}`;
+		if (options.timeSlice != null) path += `/${encodeURIComponent(options.timeSlice)}`;
+	}
+	return path;
+}
+function toQuery(params) {
+	const query = { SERVICE: "WFS" };
+	for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) query[key] = String(value);
+	return query;
+}
+/**
+* WFS endpoint wrapper (GetCapabilities, DescribeFeatureType, GetFeature and
+* WFS-T transactions).
+*
+* Token-authenticated clients use `getWfs`/`postWfs`; anonymous and HTTP-Basic
+* clients (e.g. QGIS) use the `...NoToken` variants, which include the
+* database in the path. Responses are returned as XML text.
+*/
+var Wfs = class {
+	constructor(client) {
+		this.client = client;
+	}
+	/** Token-authenticated WFS GET. */
+	async getWfs(schema, params, options) {
+		return this.client.request({
+			path: wfsPath(`api/v4/wfs/schema/${encodeURIComponent(schema)}`, options),
+			method: "GET",
+			query: toQuery(params),
+			accept: "text/xml"
+		});
+	}
+	/** Token-authenticated WFS POST (XML-encoded GetFeature or Transaction). */
+	async postWfs(schema, xml, options) {
+		return this.client.request({
+			path: wfsPath(`api/v4/wfs/schema/${encodeURIComponent(schema)}`, options),
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "text/xml"
+		});
+	}
+	/** Anonymous/HTTP-Basic WFS GET. */
+	async getWfsNoToken(schema, database, params, options) {
+		var _this3 = this;
+		const base = `api/v4/wfs/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`;
+		return _this3.client.request({
+			path: wfsPath(base, options),
+			method: "GET",
+			query: toQuery(params),
+			accept: "text/xml"
+		});
+	}
+	/** Anonymous/HTTP-Basic WFS POST (XML-encoded GetFeature or Transaction). */
+	async postWfsNoToken(schema, database, xml, options) {
+		var _this4 = this;
+		const base = `api/v4/wfs/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`;
+		return _this4.client.request({
+			path: wfsPath(base, options),
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "text/xml"
+		});
+	}
+};
+
 //#endregion
 //#region src/auth/errors.ts
 /**
@@ -2790,6 +3091,7 @@ exports.CodeFlow = CodeFlow;
 exports.Gql = Gql;
 exports.Meta = Meta;
 exports.NotLoggedInError = NotLoggedInError;
+exports.Ows = Ows;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
 exports.SessionExpiredError = SessionExpiredError;
@@ -2800,6 +3102,7 @@ exports.Stats = Stats;
 exports.Status = Status;
 exports.Tables = Tables;
 exports.Users = Users;
+exports.Wfs = Wfs;
 exports.Ws = Ws;
 exports.createApi = createApi;
 exports.createCentiaAdminClient = createCentiaAdminClient;

package/dist/centia-io-sdk.d.cts

@@ -1094,6 +1094,116 @@ interface FileProcessResponse {
   auth_str: string;
   error: string;
 }
+type LayerGeotype = 'Default' | 'POINT' | 'LINE' | 'POLYGON';
+type LayerTileFormat = 'PNG' | 'jpeg_low' | 'jpeg_medium' | 'jpeg_high';
+type LayerCacheType = 'disk' | 'sqlite' | 's3' | 'memcache';
+type LabelPosition = 'auto' | 'ul' | 'uc' | 'ur' | 'cl' | 'cc' | 'cr' | 'll' | 'lc' | 'lr';
+type FontWeight = 'normal' | 'bold' | 'italic' | 'bolditalic';
+type LineCap = 'round' | 'butt' | 'square';
+type GeomTransform = 'bbox' | 'centroid' | 'end' | 'labelpnt' | 'labelpoly' | 'start' | 'vertices';
+/** Layer properties (the def JSON). Numeric values are stored as strings, empty string when unset. */
+interface LayerProperties {
+  theme_column?: string;
+  label_column?: string;
+  opacity?: string;
+  label_max_scale?: string;
+  label_min_scale?: string;
+  cluster?: string;
+  meta_tiles?: string;
+  meta_size?: string;
+  meta_buffer?: string;
+  ttl?: string;
+  auto_expire?: string;
+  maxscaledenom?: string;
+  minscaledenom?: string;
+  symbolscaledenom?: string;
+  geotype?: LayerGeotype;
+  offsite?: string;
+  format?: LayerTileFormat;
+  lock?: boolean;
+  layers?: string;
+  bands?: string;
+  cache?: LayerCacheType;
+  s3_tile_set?: string;
+  label_no_clip?: boolean;
+  polyline_no_clip?: boolean;
+}
+/** Style entry of a class. Property keys follow MapServer STYLE parameters. */
+interface Style {
+  id?: string;
+  sortid?: number;
+  name?: string;
+  color?: string;
+  width?: string;
+  outlinecolor?: string;
+  symbol?: string;
+  size?: string;
+  angle?: string;
+  gap?: string;
+  opacity?: string;
+  pattern?: string;
+  linecap?: LineCap;
+  geomtransform?: GeomTransform;
+  minsize?: string;
+  maxsize?: string;
+  offsetx?: string;
+  offsety?: string;
+  polaroffsetr?: string;
+  polaroffsetd?: string;
+}
+/** Label entry of a class. Property keys follow MapServer LABEL parameters. */
+interface Label {
+  id?: string;
+  sortid?: number;
+  name?: string;
+  on?: boolean;
+  text?: string;
+  force?: boolean;
+  minscaledenom?: string;
+  maxscaledenom?: string;
+  position?: LabelPosition;
+  size?: string;
+  color?: string;
+  outlinecolor?: string;
+  buffer?: string;
+  repeatdistance?: string;
+  angle?: string;
+  backgroundcolor?: string;
+  backgroundpadding?: string;
+  offsetx?: string;
+  offsety?: string;
+  font?: string;
+  fontweight?: FontWeight;
+  expression?: string;
+  maxsize?: string;
+  minfeaturesize?: string;
+}
+/** Class definition with styles and labels. */
+interface LayerClass {
+  id?: string;
+  name?: string;
+  sortid?: number;
+  expression?: string;
+  styles?: Style[];
+  labels?: Label[];
+  minscaledenom?: string;
+  maxscaledenom?: string;
+  leader?: boolean;
+  leader_gridstep?: string;
+  leader_maxdistance?: string;
+  leader_color?: string;
+}
+/** Layer definition: properties (the def JSON) and classes with styles and labels. */
+interface Layer {
+  /** Layer key: schema.table.geometry_column. */
+  name: string;
+  properties?: LayerProperties;
+  classes?: LayerClass[];
+}
+interface GetLayerOptions {
+  /** Return only layer keys. */
+  namesOnly?: boolean;
+}
 interface CommitRequest {
   schema: string;
   repo: string;
@@ -1212,6 +1322,41 @@ declare class Rules {
   deleteRule(id: number): Promise<void>;
 }
 //#endregion
+//#region src/provisioning/Layers.d.ts
+declare class Layers {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private layerPath;
+  private classPath;
+  getLayer(layer?: undefined, opts?: GetLayerOptions): Promise<Layer[]>;
+  getLayer(layer: string, opts?: GetLayerOptions): Promise<Layer>;
+  /** Configure existing layer(s): set properties and replace classes. */
+  postLayer(body: Layer | Layer[]): Promise<LocationResponse>;
+  /** Update layer properties (key-merge on the def JSON). */
+  patchLayer(layer: string, body: Layer): Promise<LocationResponse>;
+  getLayerClass(layer: string): Promise<LayerClass[]>;
+  getLayerClass(layer: string, classId: string): Promise<LayerClass>;
+  postLayerClass(layer: string, body: LayerClass | LayerClass[]): Promise<LocationResponse>;
+  /** Update a class (key-merge). Styles/labels are managed via their own methods. */
+  patchLayerClass(layer: string, classId: string, body: LayerClass): Promise<LocationResponse>;
+  /** Delete class(es). `classId` may be a comma-separated list of ids. */
+  deleteLayerClass(layer: string, classId: string): Promise<void>;
+  getStyle(layer: string, classId: string): Promise<Style[]>;
+  getStyle(layer: string, classId: string, styleId: string): Promise<Style>;
+  postStyle(layer: string, classId: string, body: Style | Style[]): Promise<LocationResponse>;
+  /** Update a style (key-merge). */
+  patchStyle(layer: string, classId: string, styleId: string, body: Style): Promise<LocationResponse>;
+  /** Delete style(s). `styleId` may be a comma-separated list of ids. */
+  deleteStyle(layer: string, classId: string, styleId: string): Promise<void>;
+  getLabel(layer: string, classId: string): Promise<Label[]>;
+  getLabel(layer: string, classId: string, labelId: string): Promise<Label>;
+  postLabel(layer: string, classId: string, body: Label | Label[]): Promise<LocationResponse>;
+  /** Update a label (key-merge). */
+  patchLabel(layer: string, classId: string, labelId: string, body: Label): Promise<LocationResponse>;
+  /** Delete label(s). `labelId` may be a comma-separated list of ids. */
+  deleteLabel(layer: string, classId: string, labelId: string): Promise<void>;
+}
+//#endregion
 //#region src/provisioning/Privileges.d.ts
 declare class Privileges {
   private readonly client;
@@ -1265,7 +1410,7 @@ declare class Functions {
 declare class MetadataWrite {
   private readonly client;
   constructor(client: CentiaHttpClient);
-  patchMetaData(body: PatchMetadataRequest): Promise<unknown>;
+  patchMetaData(body: PatchMetadataRequest): Promise<LocationResponse>;
 }
 //#endregion
 //#region src/provisioning/TypeScriptInterfaces.d.ts
@@ -1302,7 +1447,7 @@ declare class GitCommit {
 interface CentiaAdminClient {
   /** The underlying HTTP client. */
   readonly http: CentiaHttpClient;
-  /** Schema, table, column, constraint, index, sequence, user, client, rule, privilege, RPC, metadata, file import, git, and SQL management. */
+  /** Schema, table, column, constraint, index, sequence, user, client, rule, privilege, RPC, layer, metadata, file import, git, and SQL management. */
   readonly provisioning: {
     readonly schemas: Schemas;
     readonly tables: ProvisioningTables;
@@ -1313,6 +1458,7 @@ interface CentiaAdminClient {
     readonly users: ProvisioningUsers;
     readonly clients: ProvisioningClients;
     readonly rules: Rules;
+    readonly layers: Layers;
     readonly privileges: Privileges;
     readonly rpcMethods: RpcMethods;
     readonly functions: Functions;
@@ -1336,6 +1482,86 @@ interface CentiaAdminClient {
  */
 declare function createCentiaAdminClient(config: CentiaClientConfig): CentiaAdminClient;
 //#endregion
+//#region src/ogc/Ows.d.ts
+/**
+ * Query parameters for OWS (WMS/WFS/UTFGRID) requests, e.g.
+ * `{ SERVICE: 'WMS', REQUEST: 'GetCapabilities' }`.
+ */
+type OwsParams = Record<string, string | number | boolean>;
+/**
+ * OWS (WMS/WFS/UTFGRID) endpoint wrapper.
+ *
+ * Token-authenticated clients use `getOws`/`postOws`; anonymous and HTTP-Basic
+ * clients use the `...NoToken` variants, which include the database in the path.
+ *
+ * Responses are streamed from the backend and returned as text (XML) or, for
+ * JSON responses such as UTFGRID, as parsed JSON. Binary responses (e.g. WMS
+ * GetMap images) are not supported by this wrapper — request those directly.
+ */
+declare class Ows {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  /** Token-authenticated OWS GET (WMS/WFS/UTFGRID). */
+  getOws<T = string>(schema: string, params?: OwsParams): Promise<T>;
+  /** Token-authenticated OWS POST (WFS XML). */
+  postOws(schema: string, xml: string): Promise<string>;
+  /** Anonymous/HTTP-Basic OWS GET (WMS/WFS/UTFGRID). */
+  getOwsNoToken<T = string>(schema: string, database: string, params?: OwsParams): Promise<T>;
+  /** Anonymous/HTTP-Basic OWS POST (WFS XML). */
+  postOwsNoToken(schema: string, database: string, xml: string): Promise<string>;
+}
+//#endregion
+//#region src/ogc/Wfs.d.ts
+/** Query parameters for WFS GET requests. Extra vendor parameters are allowed. */
+interface WfsGetParams {
+  /** OGC service. Defaults to `WFS`. */
+  SERVICE?: string;
+  /** WFS operation. */
+  REQUEST: 'GetCapabilities' | 'DescribeFeatureType' | 'GetFeature';
+  /** WFS protocol version. */
+  VERSION?: '1.0.0' | '1.1.0';
+  /** Feature type (table) name(s), comma-separated. */
+  TYPENAME?: string;
+  /** Output format, e.g. `gml3`. */
+  OUTPUTFORMAT?: string;
+  /** Requested output CRS, e.g. `urn:ogc:def:crs:EPSG::25832`. */
+  SRSNAME?: string;
+  /** Bounding-box filter (minx,miny,maxx,maxy). */
+  BBOX?: string;
+  /** Maximum number of features to return. */
+  MAXFEATURES?: number;
+  /** OGC Filter Encoding XML. */
+  FILTER?: string;
+  [key: string]: string | number | boolean | undefined;
+}
+/** Optional path segments for WFS requests. */
+interface WfsPathOptions {
+  /** Output EPSG code (SRID). */
+  srs?: number;
+  /** Version time slice (ISO date) for versioned layers. Requires `srs`. */
+  timeSlice?: string;
+}
+/**
+ * WFS endpoint wrapper (GetCapabilities, DescribeFeatureType, GetFeature and
+ * WFS-T transactions).
+ *
+ * Token-authenticated clients use `getWfs`/`postWfs`; anonymous and HTTP-Basic
+ * clients (e.g. QGIS) use the `...NoToken` variants, which include the
+ * database in the path. Responses are returned as XML text.
+ */
+declare class Wfs {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  /** Token-authenticated WFS GET. */
+  getWfs(schema: string, params: WfsGetParams, options?: WfsPathOptions): Promise<string>;
+  /** Token-authenticated WFS POST (XML-encoded GetFeature or Transaction). */
+  postWfs(schema: string, xml: string, options?: WfsPathOptions): Promise<string>;
+  /** Anonymous/HTTP-Basic WFS GET. */
+  getWfsNoToken(schema: string, database: string, params: WfsGetParams, options?: WfsPathOptions): Promise<string>;
+  /** Anonymous/HTTP-Basic WFS POST (XML-encoded GetFeature or Transaction). */
+  postWfsNoToken(schema: string, database: string, xml: string, options?: WfsPathOptions): Promise<string>;
+}
+//#endregion
 //#region src/auth/types.d.ts
 interface StoredCredentials {
   token?: string;
@@ -1445,5 +1671,5 @@ declare class SessionExpiredError extends Error {
 */
 
 //#endregion
-export { type AsyncInvocationAccepted, type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateFunctionRequest, type CreateIndexRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DryRunResult, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FullResponse, type FunctionEventOp, type FunctionInfo, type FunctionInvocationRecord, type FunctionInvocationResult, type FunctionPackage, type FunctionRuntime, type FunctionStatus, type FunctionTriggers, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, type LocationResponse, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, type Options, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFunctionRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, createTokenProvider, isCentiaApiError };
+export { type AsyncInvocationAccepted, type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateFunctionRequest, type CreateIndexRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DryRunResult, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FontWeight, type FullResponse, type FunctionEventOp, type FunctionInfo, type FunctionInvocationRecord, type FunctionInvocationResult, type FunctionPackage, type FunctionRuntime, type FunctionStatus, type FunctionTriggers, type GeomTransform, type GetLayerOptions, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, type Label, type LabelPosition, type Layer, type LayerCacheType, type LayerClass, type LayerGeotype, type LayerProperties, type LayerTileFormat, type LineCap, type LocationResponse, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, type Options, Ows, type OwsParams, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFunctionRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type Style, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, Wfs, type WfsGetParams, type WfsPathOptions, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, createTokenProvider, isCentiaApiError };
 //# sourceMappingURL=centia-io-sdk.d.cts.map