@centia-io/sdk 0.2.11 → 0.2.13

package/README.md

@@ -474,6 +474,36 @@ const job = await mapcache.deleteMapcacheTileset('my_database', 'my_schema.roads
 
 The endpoint accepts anonymous, HTTP Basic and Bearer token requests; tile requests are authorized against the tileset's layer. Authorization travels in the `Authorization` header — it cannot be embedded in the URL — so for protected tilesets, inject the header per tile request via the map library's request hook (e.g. MapLibre's `transformRequest` or OpenLayers' `tileLoadFunction`).
 
+## OGC API (Features / Maps)
+
+`Ogc` wraps the RESTful OGC API under `/api/v4/ogc/database/{database}` — OGC API Features (Part 1 Core, Part 2 CRS) for reading features as GeoJSON and OGC API Maps (Part 1 Core) for rendered images. Like `Ows`/`Wfs` it takes a `CentiaHttpClient`; Bearer token, HTTP Basic and anonymous requests are all accepted:
+
+```ts
+import { createCentiaClient, Ogc, OGC_CRS84, ogcEpsgCrs } from '@centia-io/sdk'
+
+const ogc = new Ogc(http)
+
+const { collections } = await ogc.getCollections('my_database')
+const collection = await ogc.getCollection('my_database', 'my_schema.roads') // extent, crs list, links
+
+// GeoJSON items — default page size is 10; follow the `next` link or pass offset
+const page = await ogc.getItems<{ gid: number; name: string }>('my_database', 'my_schema.roads', {
+  bbox: [9, 55, 10, 56],        // lon/lat in CRS84 (the default bbox-crs)
+  crs: ogcEpsgCrs(25832),       // output CRS from the collection's crs list
+  limit: 100,
+  datetime: '2024-01-01T00:00:00Z', // versioned layers: the version valid at that time
+})
+page.numberMatched // total; page.numberReturned; page.links (next/prev)
+
+const feature = await ogc.getItem('my_database', 'my_schema.roads', 42)
+
+// Map images are fetched by URL (e.g. an <img> or a map library)
+const url = ogc.mapUrl('my_database', 'my_schema.roads', { bbox: [9, 55, 10, 56], width: 512, format: 'png' })
+const multi = ogc.datasetMapUrl('my_database', ['my_schema.roads', 'my_schema.buildings'], { width: 512 })
+```
+
+CRS values are URIs: `OGC_CRS84` (lon/lat, default) or `ogcEpsgCrs(code)`; note `ogcEpsgCrs(4326)` is lat/lon order per OGC API Features Part 2. A collection that exists but is not readable answers `401` (anonymous) or `403` (no privilege); unknown collections and features are `404` — all thrown as `CentiaApiError`. Geofence rules, versioning and workflow are applied server-side.
+
 ## Key/value store
 
 `Keyvalue` wraps the `/api/v4/keyvalue` endpoints for storing arbitrary JSON under globally unique keys. It takes a `CentiaHttpClient` and requires a Bearer token:
@@ -538,8 +568,9 @@ await features.patchFeature('my_schema', 'my_table', {
   properties: { name: 'Moved point' },
 }, { feature: 1 })
 
-// Delete a single feature (204)
+// Delete one or more features (204; 404 only when no key matches)
 await features.deleteFeature('my_schema', 'my_table', 1)
+await features.deleteFeature('my_schema', 'my_table', [1, 2, 3])
 ```
 
 `srs` on `postFeature`/`patchFeature` declares the SRID of the *incoming* geometry. Reading requires a key — use the SQL or WFS APIs to query whole collections. PUT is not supported.

package/dist/centia-io-sdk.cjs

@@ -3041,6 +3041,157 @@ var Mapcache = class {
 	}
 };
 
+//#endregion
+//#region src/ogc/Ogc.ts
+/** Default CRS of the OGC API: WGS 84 in longitude/latitude order. */
+const OGC_CRS84 = "http://www.opengis.net/def/crs/OGC/1.3/CRS84";
+/**
+* CRS URI for an EPSG code, e.g. `ogcEpsgCrs(25832)`. Note that
+* `ogcEpsgCrs(4326)` is latitude/longitude order; use `OGC_CRS84` for lon/lat.
+*/
+function ogcEpsgCrs(epsg) {
+	return `http://www.opengis.net/def/crs/EPSG/0/${epsg}`;
+}
+function bboxToString(bbox) {
+	return typeof bbox === "string" ? bbox : bbox.join(",");
+}
+function spatialQuery(options) {
+	const query = {};
+	if ((options === null || options === void 0 ? void 0 : options.bbox) !== void 0) query.bbox = bboxToString(options.bbox);
+	if ((options === null || options === void 0 ? void 0 : options.bboxCrs) !== void 0) query["bbox-crs"] = options.bboxCrs;
+	if ((options === null || options === void 0 ? void 0 : options.crs) !== void 0) query.crs = options.crs;
+	if ((options === null || options === void 0 ? void 0 : options.datetime) !== void 0) query.datetime = options.datetime;
+	return query;
+}
+function nonEmpty(query) {
+	return Object.keys(query).length > 0 ? query : void 0;
+}
+/**
+* OGC API Features (Part 1 Core, Part 2 CRS) and OGC API Maps (Part 1 Core)
+* wrapper for `/api/v4/ogc/database/{database}`.
+*
+* The endpoints accept Bearer token, HTTP Basic and anonymous requests. A
+* Bearer token must match the `database` in the path. Anonymous callers read
+* layers below `Read/write`; a `Read/write` collection answers 401 (Basic
+* challenge) for anonymous callers and 403 for identities without privilege.
+* Geofence rules, versioning and workflow are applied server-side.
+*
+* Map images cannot be fetched through this client; use `mapUrl` /
+* `datasetMapUrl` to build image URLs for `<img>` tags or map libraries.
+*
+* ```ts
+* const ogc = new Ogc(createCentiaClient({ baseUrl, auth }));
+* const page = await ogc.getItems('my_database', 'my_schema.roads', { bbox: [9, 55, 10, 56], limit: 100 });
+* ```
+*/
+var Ogc = class {
+	constructor(client) {
+		this.client = client;
+	}
+	basePath(database) {
+		return `api/v4/ogc/database/${encodeURIComponent(database)}`;
+	}
+	collectionPath(database, collectionId) {
+		return `${this.basePath(database)}/collections/${encodeURIComponent(collectionId)}`;
+	}
+	/** The landing page with links to conformance, collections and the OpenAPI document. */
+	async getLandingPage(database) {
+		var _this = this;
+		return _this.client.request({
+			path: _this.basePath(database),
+			method: "GET"
+		});
+	}
+	/** Conformance classes implemented by the server. */
+	async getConformance(database) {
+		var _this2 = this;
+		return _this2.client.request({
+			path: `${_this2.basePath(database)}/conformance`,
+			method: "GET"
+		});
+	}
+	/** The collections (OWS-enabled layers) the caller may read, paged. */
+	async getCollections(database, options) {
+		var _this3 = this;
+		const query = {};
+		if ((options === null || options === void 0 ? void 0 : options.limit) !== void 0) query.limit = String(options.limit);
+		if ((options === null || options === void 0 ? void 0 : options.offset) !== void 0) query.offset = String(options.offset);
+		return _this3.client.request({
+			path: `${_this3.basePath(database)}/collections`,
+			method: "GET",
+			query: nonEmpty(query)
+		});
+	}
+	/**
+	* One collection. Throws a `CentiaApiError` with status 404 (unknown),
+	* 401 (anonymous caller, credentials required) or 403 (no privilege).
+	*/
+	async getCollection(database, collectionId) {
+		var _this4 = this;
+		return _this4.client.request({
+			path: _this4.collectionPath(database, collectionId),
+			method: "GET"
+		});
+	}
+	/**
+	* Features of a collection as a GeoJSON FeatureCollection page. The default
+	* page size is 10; follow `links` with `rel: 'next'` or pass `offset`.
+	*/
+	async getItems(database, collectionId, options) {
+		var _this5 = this;
+		const query = {};
+		if ((options === null || options === void 0 ? void 0 : options.limit) !== void 0) query.limit = String(options.limit);
+		if ((options === null || options === void 0 ? void 0 : options.offset) !== void 0) query.offset = String(options.offset);
+		Object.assign(query, spatialQuery(options));
+		return _this5.client.request({
+			path: `${_this5.collectionPath(database, collectionId)}/items`,
+			method: "GET",
+			query: nonEmpty(query),
+			accept: "application/geo+json"
+		});
+	}
+	/** One feature by primary key. Throws a 404 `CentiaApiError` when it does not exist. */
+	async getItem(database, collectionId, featureId, options) {
+		var _this6 = this;
+		const query = {};
+		if ((options === null || options === void 0 ? void 0 : options.crs) !== void 0) query.crs = options.crs;
+		if ((options === null || options === void 0 ? void 0 : options.datetime) !== void 0) query.datetime = options.datetime;
+		return _this6.client.request({
+			path: `${_this6.collectionPath(database, collectionId)}/items/${encodeURIComponent(String(featureId))}`,
+			method: "GET",
+			query: nonEmpty(query),
+			accept: "application/geo+json"
+		});
+	}
+	/**
+	* URL of a rendered map of one collection (PNG/JPEG), without fetching it.
+	* Authorization travels in the `Authorization` header, so for protected
+	* collections fetch the image with the header set (or use Basic auth).
+	*/
+	mapUrl(database, collectionId, options) {
+		return this.buildUrl(`${this.collectionPath(database, collectionId)}/map`, this.mapQuery(options));
+	}
+	/** URL of a rendered map of several collections of the same schema. */
+	datasetMapUrl(database, collections, options) {
+		const query = _objectSpread2({ collections: collections.join(",") }, this.mapQuery(options));
+		return this.buildUrl(`${this.basePath(database)}/map`, query);
+	}
+	mapQuery(options) {
+		const query = spatialQuery(options);
+		if ((options === null || options === void 0 ? void 0 : options.width) !== void 0) query.width = String(options.width);
+		if ((options === null || options === void 0 ? void 0 : options.height) !== void 0) query.height = String(options.height);
+		if ((options === null || options === void 0 ? void 0 : options.format) !== void 0) query.f = options.format;
+		if ((options === null || options === void 0 ? void 0 : options.transparent) !== void 0) query.transparent = String(options.transparent);
+		if ((options === null || options === void 0 ? void 0 : options.bgcolor) !== void 0) query.bgcolor = options.bgcolor;
+		return query;
+	}
+	buildUrl(path, query) {
+		let url = `${this.client.baseUrl}/${path}`;
+		if (Object.keys(query).length > 0) url += `?${new URLSearchParams(query).toString()}`;
+		return url;
+	}
+};
+
 //#endregion
 //#region src/keyvalue/Keyvalue.ts
 /**
@@ -3164,7 +3315,11 @@ var Features = class {
 			expectedStatus: 303
 		})).getHeader("Location")) !== null && _res$getHeader2 !== void 0 ? _res$getHeader2 : "" };
 	}
-	/** Delete a single feature by primary key. */
+	/**
+	* Delete one or more features by primary key. Keys that match are deleted
+	* in one WFS-T transaction; a 404 `CentiaApiError` is thrown only when
+	* none of the keys match.
+	*/
 	async deleteFeature(schema, table, feature) {
 		await this.client.request({
 			path: featurePath(schema, table, feature),
@@ -3305,6 +3460,8 @@ exports.Keyvalue = Keyvalue;
 exports.Mapcache = Mapcache;
 exports.Meta = Meta;
 exports.NotLoggedInError = NotLoggedInError;
+exports.OGC_CRS84 = OGC_CRS84;
+exports.Ogc = Ogc;
 exports.Ows = Ows;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
@@ -3323,4 +3480,5 @@ exports.createCentiaAdminClient = createCentiaAdminClient;
 exports.createCentiaClient = createCentiaClient;
 exports.createSqlBuilder = createSqlBuilder;
 exports.createTokenProvider = createTokenProvider;
-exports.isCentiaApiError = isCentiaApiError;
+exports.isCentiaApiError = isCentiaApiError;
+exports.ogcEpsgCrs = ogcEpsgCrs;

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

@@ -1655,55 +1655,6 @@ declare class Mapcache {
   mapcacheUrl(database: string, path?: string, params?: MapcacheParams): string;
 }
 //#endregion
-//#region src/keyvalue/Keyvalue.d.ts
-/** A stored key/value entry. */
-interface KeyvalueEntry<T = unknown> {
-  id: number;
-  key: string;
-  /** The stored JSON value, returned decoded. */
-  value: T;
-  /** Screen name of the owning user; null for legacy keys created without an owner. */
-  owner: string | null;
-  /** When true the key is readable by any user in the database. */
-  public: boolean;
-}
-/** Body for creating a key. `owner` is always set server-side from the JWT and cannot be sent. */
-interface CreateKeyvalueRequest<T = unknown> {
-  value: T;
-  public?: boolean;
-}
-/** Partial update of a key's value and/or public flag. */
-interface PatchKeyvalueRequest<T = unknown> {
-  value?: T;
-  public?: boolean;
-}
-/** Result of a paths-projected GET: only the requested sub-trees, keyed by each path string. */
-interface KeyvalueProjection {
-  value: Record<string, unknown>;
-}
-/**
- * Client for the key/value store (`/api/v4/keyvalue`).
- *
- * Keys are globally unique. Super users have full CRUD on all keys; sub-users
- * can read their own keys plus all public keys, and can only modify their own.
- *
- * ```ts
- * const kv = new Keyvalue(createCentiaClient({ baseUrl, auth }));
- * await kv.postKeyvalue('settings', { value: { theme: 'dark' } });
- * const entry = await kv.getKeyvalue('settings');
- * ```
- */
-declare class Keyvalue {
-  private readonly client;
-  constructor(client: CentiaHttpClient);
-  getKeyvalue(): Promise<KeyvalueEntry[]>;
-  getKeyvalue<T = unknown>(key: string): Promise<KeyvalueEntry<T>>;
-  getKeyvalue(key: string, paths: string | string[]): Promise<KeyvalueProjection>;
-  postKeyvalue<T = unknown>(key: string, body: CreateKeyvalueRequest<T>): Promise<LocationResponse>;
-  patchKeyvalue<T = unknown>(key: string, body: PatchKeyvalueRequest<T>): Promise<LocationResponse>;
-  deleteKeyvalue(key: string): Promise<void>;
-}
-//#endregion
 //#region src/features/Features.d.ts
 /** A GeoJSON geometry object. Coordinates are lon/lat for EPSG:4326. */
 interface GeoJsonGeometry {
@@ -1770,8 +1721,229 @@ declare class Features {
    * feature must carry its primary-key value in `properties`.
    */
   patchFeature(schema: string, table: string, body: GeoJsonFeature | GeoJsonFeatureCollection, options?: PatchFeatureOptions): Promise<LocationResponse>;
-  /** Delete a single feature by primary key. */
-  deleteFeature(schema: string, table: string, feature: string | number): Promise<void>;
+  /**
+   * Delete one or more features by primary key. Keys that match are deleted
+   * in one WFS-T transaction; a 404 `CentiaApiError` is thrown only when
+   * none of the keys match.
+   */
+  deleteFeature(schema: string, table: string, feature: FeatureKey): Promise<void>;
+}
+//#endregion
+//#region src/ogc/Ogc.d.ts
+/** Default CRS of the OGC API: WGS 84 in longitude/latitude order. */
+declare const OGC_CRS84 = "http://www.opengis.net/def/crs/OGC/1.3/CRS84";
+/**
+ * CRS URI for an EPSG code, e.g. `ogcEpsgCrs(25832)`. Note that
+ * `ogcEpsgCrs(4326)` is latitude/longitude order; use `OGC_CRS84` for lon/lat.
+ */
+declare function ogcEpsgCrs(epsg: number): string;
+/** A link object as used throughout the OGC API. */
+interface OgcLink {
+  rel: string;
+  href: string;
+  type?: string;
+  title?: string;
+}
+/** The landing page of a database's OGC API. */
+interface OgcLandingPage {
+  title: string;
+  description?: string;
+  links: OgcLink[];
+}
+/** Conformance classes implemented by the server. */
+interface OgcConformance {
+  conformsTo: string[];
+}
+/** Spatial and temporal extent of a collection. */
+interface OgcExtent {
+  spatial?: {
+    bbox: number[][];
+    crs?: string;
+  };
+  temporal?: {
+    interval: Array<Array<string | null>>;
+    trs?: string;
+  };
+}
+/** One collection (an OWS-enabled layer, id = `schema.table`). */
+interface OgcCollection {
+  id: string;
+  title?: string;
+  description?: string;
+  /** `feature` for vector layers; absent for raster layers (map only). */
+  itemType?: string;
+  extent?: OgcExtent;
+  /** CRS URIs accepted by `crs`/`bbox-crs`. */
+  crs?: string[];
+  storageCrs?: string;
+  links: OgcLink[];
+}
+/** A page of collections. */
+interface OgcCollections {
+  links: OgcLink[];
+  numberMatched: number;
+  numberReturned: number;
+  collections: OgcCollection[];
+}
+/** A GeoJSON Feature as returned by the OGC API (with links on single items). */
+interface OgcFeature<P$1 = Record<string, unknown>> extends GeoJsonFeature<P$1> {
+  links?: OgcLink[];
+}
+/** A GeoJSON FeatureCollection page as returned by `/items`. */
+interface OgcFeatureCollection<P$1 = Record<string, unknown>> extends GeoJsonFeatureCollection<P$1> {
+  features: OgcFeature<P$1>[];
+  numberMatched?: number;
+  numberReturned: number;
+  timeStamp?: string;
+  links: OgcLink[];
+}
+/** Options for `getCollections`. */
+interface OgcCollectionsOptions {
+  /** Page size (default 100, max 1000). */
+  limit?: number;
+  /** Collections to skip. */
+  offset?: number;
+}
+/** A bounding box: `[minx, miny, maxx, maxy]` in the axis order of its CRS, or the same as a comma-separated string. */
+type OgcBbox = [number, number, number, number] | number[] | string;
+/** Options shared by items and map requests. */
+interface OgcSpatialOptions {
+  /** Bounding box in the axis order of `bboxCrs` (default CRS84 = lon/lat). */
+  bbox?: OgcBbox;
+  /** CRS URI of `bbox`. Defaults to CRS84. */
+  bboxCrs?: string;
+  /** Output CRS URI from the collection's `crs` list. Defaults to CRS84. */
+  crs?: string;
+  /**
+   * ISO 8601 instant. On a versioned layer, the version valid at that time;
+   * ignored on other layers. Intervals are not supported.
+   */
+  datetime?: string;
+}
+/** Options for `getItems`. */
+interface OgcItemsOptions extends OgcSpatialOptions {
+  /** Page size (default 10, max 10000). */
+  limit?: number;
+  /** Features to skip. */
+  offset?: number;
+}
+/** Options for `getItem`. */
+interface OgcItemOptions {
+  crs?: string;
+  datetime?: string;
+}
+/** Options for map URLs. */
+interface OgcMapOptions extends OgcSpatialOptions {
+  /** Image width in pixels (max 16384). */
+  width?: number;
+  /** Image height in pixels (max 16384). Missing dimensions follow the bbox aspect ratio. */
+  height?: number;
+  /** `png` (default, transparent) or `jpeg` (opaque). */
+  format?: 'png' | 'jpeg';
+  transparent?: boolean;
+  /** Background colour as `0xRRGGBB`. */
+  bgcolor?: string;
+}
+/**
+ * OGC API Features (Part 1 Core, Part 2 CRS) and OGC API Maps (Part 1 Core)
+ * wrapper for `/api/v4/ogc/database/{database}`.
+ *
+ * The endpoints accept Bearer token, HTTP Basic and anonymous requests. A
+ * Bearer token must match the `database` in the path. Anonymous callers read
+ * layers below `Read/write`; a `Read/write` collection answers 401 (Basic
+ * challenge) for anonymous callers and 403 for identities without privilege.
+ * Geofence rules, versioning and workflow are applied server-side.
+ *
+ * Map images cannot be fetched through this client; use `mapUrl` /
+ * `datasetMapUrl` to build image URLs for `<img>` tags or map libraries.
+ *
+ * ```ts
+ * const ogc = new Ogc(createCentiaClient({ baseUrl, auth }));
+ * const page = await ogc.getItems('my_database', 'my_schema.roads', { bbox: [9, 55, 10, 56], limit: 100 });
+ * ```
+ */
+declare class Ogc {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  private collectionPath;
+  /** The landing page with links to conformance, collections and the OpenAPI document. */
+  getLandingPage(database: string): Promise<OgcLandingPage>;
+  /** Conformance classes implemented by the server. */
+  getConformance(database: string): Promise<OgcConformance>;
+  /** The collections (OWS-enabled layers) the caller may read, paged. */
+  getCollections(database: string, options?: OgcCollectionsOptions): Promise<OgcCollections>;
+  /**
+   * One collection. Throws a `CentiaApiError` with status 404 (unknown),
+   * 401 (anonymous caller, credentials required) or 403 (no privilege).
+   */
+  getCollection(database: string, collectionId: string): Promise<OgcCollection>;
+  /**
+   * Features of a collection as a GeoJSON FeatureCollection page. The default
+   * page size is 10; follow `links` with `rel: 'next'` or pass `offset`.
+   */
+  getItems<P$1 = Record<string, unknown>>(database: string, collectionId: string, options?: OgcItemsOptions): Promise<OgcFeatureCollection<P$1>>;
+  /** One feature by primary key. Throws a 404 `CentiaApiError` when it does not exist. */
+  getItem<P$1 = Record<string, unknown>>(database: string, collectionId: string, featureId: string | number, options?: OgcItemOptions): Promise<OgcFeature<P$1>>;
+  /**
+   * URL of a rendered map of one collection (PNG/JPEG), without fetching it.
+   * Authorization travels in the `Authorization` header, so for protected
+   * collections fetch the image with the header set (or use Basic auth).
+   */
+  mapUrl(database: string, collectionId: string, options?: OgcMapOptions): string;
+  /** URL of a rendered map of several collections of the same schema. */
+  datasetMapUrl(database: string, collections: string[], options?: OgcMapOptions): string;
+  private mapQuery;
+  private buildUrl;
+}
+//#endregion
+//#region src/keyvalue/Keyvalue.d.ts
+/** A stored key/value entry. */
+interface KeyvalueEntry<T = unknown> {
+  id: number;
+  key: string;
+  /** The stored JSON value, returned decoded. */
+  value: T;
+  /** Screen name of the owning user; null for legacy keys created without an owner. */
+  owner: string | null;
+  /** When true the key is readable by any user in the database. */
+  public: boolean;
+}
+/** Body for creating a key. `owner` is always set server-side from the JWT and cannot be sent. */
+interface CreateKeyvalueRequest<T = unknown> {
+  value: T;
+  public?: boolean;
+}
+/** Partial update of a key's value and/or public flag. */
+interface PatchKeyvalueRequest<T = unknown> {
+  value?: T;
+  public?: boolean;
+}
+/** Result of a paths-projected GET: only the requested sub-trees, keyed by each path string. */
+interface KeyvalueProjection {
+  value: Record<string, unknown>;
+}
+/**
+ * Client for the key/value store (`/api/v4/keyvalue`).
+ *
+ * Keys are globally unique. Super users have full CRUD on all keys; sub-users
+ * can read their own keys plus all public keys, and can only modify their own.
+ *
+ * ```ts
+ * const kv = new Keyvalue(createCentiaClient({ baseUrl, auth }));
+ * await kv.postKeyvalue('settings', { value: { theme: 'dark' } });
+ * const entry = await kv.getKeyvalue('settings');
+ * ```
+ */
+declare class Keyvalue {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getKeyvalue(): Promise<KeyvalueEntry[]>;
+  getKeyvalue<T = unknown>(key: string): Promise<KeyvalueEntry<T>>;
+  getKeyvalue(key: string, paths: string | string[]): Promise<KeyvalueProjection>;
+  postKeyvalue<T = unknown>(key: string, body: CreateKeyvalueRequest<T>): Promise<LocationResponse>;
+  patchKeyvalue<T = unknown>(key: string, body: PatchKeyvalueRequest<T>): Promise<LocationResponse>;
+  deleteKeyvalue(key: string): Promise<void>;
 }
 //#endregion
 //#region src/auth/types.d.ts
@@ -1883,5 +2055,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 CreateKeyvalueRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DeleteMapcacheTilesetOptions, type DryRunResult, type FeatureKey, type FeatureSrsOptions, Features, 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 GeoJsonFeature, type GeoJsonFeatureCollection, type GeoJsonGeometry, type GeomTransform, type GetLayerOptions, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, Keyvalue, type KeyvalueEntry, type KeyvalueProjection, type Label, type LabelPosition, type Layer, type LayerCacheType, type LayerClass, type LayerGeotype, type LayerProperties, type LayerTileFormat, type LineCap, type LocationResponse, type MapConfig, Mapcache, type MapcacheParams, type MapcacheTilesetDeleteResult, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, type Options, Ows, type OwsParams, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFeatureOptions, type PatchFunctionRequest, type PatchKeyvalueRequest, 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 };
+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 CreateKeyvalueRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DeleteMapcacheTilesetOptions, type DryRunResult, type FeatureKey, type FeatureSrsOptions, Features, 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 GeoJsonFeature, type GeoJsonFeatureCollection, type GeoJsonGeometry, type GeomTransform, type GetLayerOptions, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, Keyvalue, type KeyvalueEntry, type KeyvalueProjection, type Label, type LabelPosition, type Layer, type LayerCacheType, type LayerClass, type LayerGeotype, type LayerProperties, type LayerTileFormat, type LineCap, type LocationResponse, type MapConfig, Mapcache, type MapcacheParams, type MapcacheTilesetDeleteResult, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, OGC_CRS84, Ogc, type OgcBbox, type OgcCollection, type OgcCollections, type OgcCollectionsOptions, type OgcConformance, type OgcExtent, type OgcFeature, type OgcFeatureCollection, type OgcItemOptions, type OgcItemsOptions, type OgcLandingPage, type OgcLink, type OgcMapOptions, type OgcSpatialOptions, type Options, Ows, type OwsParams, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFeatureOptions, type PatchFunctionRequest, type PatchKeyvalueRequest, 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, ogcEpsgCrs };
 //# sourceMappingURL=centia-io-sdk.d.cts.map