@centia-io/sdk 0.0.43 → 0.0.45

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

@@ -14,6 +14,7 @@ type Options = {
   deviceUri?: string;
   scope?: string;
   clientId: string;
+  clientSecret?: string;
 };
 type CodeFlowOptions = Options & {
   redirectUri: string;
@@ -95,11 +96,115 @@ declare class PasswordFlow {
   signOut(): void;
   clear(): void;
 }
+//#endregion
+//#region src/http/types.d.ts
+/**
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ */
+/** Auth injection callbacks for the HTTP client. */
+interface CentiaAuth {
+  /** Returns a Bearer token. Called before each request. */
+  getAccessToken?: () => Promise<string | undefined>;
+  /**
+   * Returns additional headers. Merged after getAccessToken,
+   * so it can override Authorization if needed.
+   */
+  getHeaders?: () => Promise<Record<string, string>>;
+}
+/** Configuration for createCentiaClient(). */
+interface CentiaClientConfig {
+  /** Base URL of the Centia API (e.g. "https://example.centia.io"). */
+  baseUrl: string;
+  /** Auth injection. If omitted, requests are unauthenticated. */
+  auth?: CentiaAuth;
+  /** Custom fetch implementation. Defaults to globalThis.fetch. */
+  fetch?: typeof globalThis.fetch;
+  /** User-Agent header (ignored in browsers). */
+  userAgent?: string;
+}
+/** Options for a single HTTP request via CentiaHttpClient. */
+interface RequestOptions {
+  /** URL path relative to baseUrl (e.g. "api/v4/sql"). Leading slash is stripped. */
+  path: string;
+  /** HTTP method. */
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  /** Request body. Serialized as JSON unless contentType overrides. */
+  body?: unknown;
+  /** Query parameters appended to the URL. */
+  query?: Record<string, string>;
+  /** Content-Type header. Defaults to "application/json". Set to null to omit. */
+  contentType?: string | null;
+  /** Accept header. Defaults to "application/json". */
+  accept?: string;
+  /** Expected HTTP status code. Defaults to 200. Non-match throws CentiaApiError. */
+  expectedStatus?: number;
+}
+/** Full HTTP response with metadata, returned by CentiaHttpClient.requestFull(). */
+interface FullResponse<T> {
+  /** Parsed response body (null for empty responses like 204). */
+  body: T;
+  /** HTTP status code. */
+  status: number;
+  /** Get a response header value by name. */
+  getHeader(name: string): string | null;
+}
+//#endregion
+//#region src/http/client.d.ts
+/**
+ * Unified HTTP client for the Centia API.
+ * Works in both Node.js and browser environments.
+ */
+declare class CentiaHttpClient {
+  private readonly baseUrl;
+  private readonly auth;
+  private readonly fetchFn;
+  private readonly userAgent;
+  constructor(config: CentiaClientConfig);
+  /**
+   * Execute an HTTP request against the Centia API.
+   * Returns parsed JSON on success. Throws CentiaApiError on non-expected status.
+   */
+  request<T = unknown>(opts: RequestOptions): Promise<T>;
+  /**
+   * Execute an HTTP request and return the full response including headers.
+   * Useful for operations that return Location headers (POST 201, PATCH 303).
+   */
+  requestFull<T = unknown>(opts: RequestOptions): Promise<FullResponse<T>>;
+  private buildUrl;
+  private buildHeaders;
+  private resolveContentType;
+  private handleResponse;
+}
+/**
+ * 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() },
+ * });
+ * ```
+ */
+declare function createCentiaClient(config: CentiaClientConfig): CentiaHttpClient;
 declare namespace pgTypes_d_exports {
-  export { BPChar, Box, Char, Circle, ColumnSchemaMeta, DataRow, DateRange, DateString, DecimalString, Int4Range, Int8Range, IntervalValue, JsonArray, JsonObject, JsonPrimitive, JsonValue, Line, Lseg, NumRange, NumericString, Path, PgArray, PgBoolean, Point, Polygon, Range, RowValue, RpcRequest, RpcResponse, SQLResponse, SqlRequest, Text, TimeString, TimestampString, TimestamptzString, TimetzString, TsRange, TstzRange, TypedSqlRequest, Varchar };
+  export { BPChar, Box, Char, Circle, ColumnSchemaMeta, DataRow, DateRange, DateString, DecimalString, GqlRequest, GqlResponse, Int4Range, Int8Range, IntervalValue, JsonArray, JsonObject, JsonPrimitive, JsonValue, Line, Lseg, NumRange, NumericString, Path, PgArray, PgBoolean, Point, Polygon, Range, RowValue, RpcRequest, RpcResponse, SqlRequest, SqlResponse, Text, TimeString, TimestampString, TimestamptzString, TimetzString, TsRange, TstzRange, TypedSqlRequest, Varchar };
 }
 /**
- * These types model the request/response payloads and complex values
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ *
  */
 type JsonPrimitive = string | number | boolean | null;
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
@@ -165,29 +270,41 @@ type DateRange = Range<DateString>;
 type PgArray<T> = T[];
 interface SqlRequest<Params extends Record<string, unknown> = Record<string, unknown>> {
   q: string;
-  params?: Params;
+  params?: Params[];
   type_hints?: Record<string, string>;
   type_formats?: Record<string, string>;
 }
+interface SqlResponse<Row extends DataRow = DataRow> {
+  schema: Record<string, ColumnSchemaMeta>;
+  data: Row[];
+}
 interface TypedSqlRequest<Row extends DataRow, Params extends Record<string, unknown> = Record<string, unknown>> extends SqlRequest<Params> {
   readonly __row?: Row;
 }
 interface RpcRequest<Params extends Record<string, unknown> = Record<string, unknown>> {
   jsonrpc: "2.0";
   method: string;
-  params?: Params;
+  params?: Params[];
   id?: number | string;
 }
+interface GqlRequest {
+  query: string;
+  variables?: Record<string, unknown>;
+  operationName?: string;
+  extensions?: Record<string, unknown>;
+}
+interface GqlResponse {
+  data?: Record<string, unknown>;
+  errors?: Array<{
+    message: string;
+  }>;
+}
 interface ColumnSchemaMeta {
   type: string;
   array: boolean;
 }
 type RowValue = number | string | PgBoolean | JsonValue | DateString | TimeString | TimetzString | TimestampString | TimestamptzString | IntervalValue | Point | Line | Lseg | Box | Path | Polygon | Circle | Int4Range | Int8Range | NumRange | TsRange | TstzRange | DateRange | PgArray<any> | null;
 type DataRow = Record<string, RowValue>;
-interface SQLResponse<Row extends DataRow = DataRow> {
-  schema: Record<string, ColumnSchemaMeta>;
-  data: Row[];
-}
 interface RpcResponse<Row extends DataRow = DataRow> {
   jsonrpc: "2.0";
   result: {
@@ -199,33 +316,61 @@ interface RpcResponse<Row extends DataRow = DataRow> {
 //#endregion
 //#region src/Sql.d.ts
 declare class Sql {
-  exec<R extends DataRow>(request: TypedSqlRequest<R>): Promise<SQLResponse<R>>;
-  exec(request: SqlRequest): Promise<SQLResponse<DataRow>>;
+  private client;
+  constructor(client?: CentiaHttpClient);
+  exec<R$1 extends DataRow>(request: TypedSqlRequest<R$1>): Promise<SqlResponse<R$1>>;
+  exec(request: SqlRequest): Promise<SqlResponse<DataRow>>;
 }
 //#endregion
 //#region src/Rpc.d.ts
 declare class Rpc {
+  private client;
+  constructor(client?: CentiaHttpClient);
   call(request: RpcRequest): Promise<RpcResponse>;
 }
 //#endregion
+//#region src/Gql.d.ts
+declare class Gql {
+  private schema;
+  private client;
+  constructor(schema: string, client?: CentiaHttpClient);
+  request(request: GqlRequest): Promise<GqlResponse>;
+}
+//#endregion
 //#region src/Meta.d.ts
 declare class Meta {
+  private client;
+  constructor(client?: CentiaHttpClient);
   query(rel: string): Promise<any>;
 }
 //#endregion
 //#region src/Status.d.ts
+/**
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ *
+ */
 declare class Status {
   isAuth(): boolean;
   getTokens(): Tokens;
 }
 //#endregion
 //#region src/Claims.d.ts
+/**
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ *
+ */
 declare class Claims {
   get(): any;
 }
 //#endregion
 //#region src/Users.d.ts
 declare class Users {
+  private client;
+  constructor(client?: CentiaHttpClient);
   get(user: string): Promise<any>;
 }
 //#endregion
@@ -238,11 +383,15 @@ declare class Ws {
 //#endregion
 //#region src/Stats.d.ts
 declare class Stats {
+  private client;
+  constructor(client?: CentiaHttpClient);
   get(): Promise<any>;
 }
 //#endregion
 //#region src/Tables.d.ts
 declare class Tables {
+  private client;
+  constructor(client?: CentiaHttpClient);
   get(schema: string, table: string): Promise<any>;
   create(schema: string, table: string, payload: any): Promise<any>;
   patch(schema: string, table: string, payload: any): Promise<any>;
@@ -253,10 +402,10 @@ declare class Tables {
 type MethodsOf<T> = { [K in keyof T]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => R : never };
 type RowOfApiCall<F> = F extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E : R : never;
 type RowsOfApiCall<F> = F extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E[] : R[] : never;
-type RowOfApiMethod<A, K extends keyof A> = A[K] extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E : R : never;
-type RowsOfApiMethod<A, K extends keyof A> = A[K] extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E[] : R[] : never;
-type ParamsOfApiMethod<A, K extends keyof A> = A[K] extends ((...args: infer P) => any) ? P[0] : never;
-declare function createApi<T>(): MethodsOf<T>;
+type RowOfApiMethod<A$1, K$1 extends keyof A$1> = A$1[K$1] extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E : R : never;
+type RowsOfApiMethod<A$1, K$1 extends keyof A$1> = A$1[K$1] extends ((...args: any[]) => Promise<infer R>) ? R extends ReadonlyArray<infer E> ? E[] : R[] : never;
+type ParamsOfApiMethod<A$1, K$1 extends keyof A$1> = A$1[K$1] extends ((...args: infer P) => any) ? P[0] : never;
+declare function createApi<T>(client?: CentiaHttpClient): MethodsOf<T>;
 //#endregion
 //#region src/SignUp.d.ts
 declare class SignUp {
@@ -275,7 +424,7 @@ interface ColumnDef {
   type?: string;
   [key: string]: any;
 }
-interface ConstraintDef {
+interface ConstraintDef$1 {
   name: string;
   constraint: "primary" | "foreign" | string;
   columns?: readonly string[];
@@ -286,7 +435,7 @@ interface ConstraintDef {
 interface TableDef {
   name: string;
   columns: readonly ColumnDef[];
-  constraints?: readonly ConstraintDef[];
+  constraints?: readonly ConstraintDef$1[];
   [key: string]: any;
 }
 interface DBSchema {
@@ -309,12 +458,12 @@ type PrimaryKeyColumns<S extends DBSchema, TN extends string> = PrimaryConstrain
 } ? A : never;
 type IsTupleOfLength1<T extends readonly any[]> = T extends readonly [any] ? true : false;
 type PrimaryKeyValue<S extends DBSchema, TN extends string> = PrimaryKeyColumns<S, TN> extends infer PK extends readonly string[] ? PK extends never ? never : IsTupleOfLength1<PK> extends true ? ColumnValueFor<S, TN, PK[0]> : { [K in PK[number]]: ColumnValueFor<S, TN, K> } : never;
-type ColumnValueFromDef<C extends ColumnDef> = C["_is_array"] extends true ? PgArray<ScalarFromTypename<C["_typname"]>> : ScalarFromTypename<C["_typname"]>;
-type NullableColumnValueFromDef<C extends ColumnDef> = C["is_nullable"] extends true ? ColumnValueFromDef<C> | null : ColumnValueFromDef<C>;
-type ColumnDefByName<S extends DBSchema, TN extends string, K extends string> = Extract<ColumnsOf<S, TN>[number], {
-  name: K;
+type ColumnValueFromDef<C$1 extends ColumnDef> = C$1["_is_array"] extends true ? PgArray<ScalarFromTypename<C$1["_typname"]>> : ScalarFromTypename<C$1["_typname"]>;
+type NullableColumnValueFromDef<C$1 extends ColumnDef> = C$1["is_nullable"] extends true ? ColumnValueFromDef<C$1> | null : ColumnValueFromDef<C$1>;
+type ColumnDefByName<S extends DBSchema, TN extends string, K$1 extends string> = Extract<ColumnsOf<S, TN>[number], {
+  name: K$1;
 }>;
-type ColumnValueFor<S extends DBSchema, TN extends string, K extends string> = NullableColumnValueFromDef<ColumnDefByName<S, TN, K>>;
+type ColumnValueFor<S extends DBSchema, TN extends string, K$1 extends string> = NullableColumnValueFromDef<ColumnDefByName<S, TN, K$1>>;
 type ValuesForTable<S extends DBSchema, TN extends string> = Partial<{ [K in ColumnNames<S, TN>]: NullableColumnValueFromDef<Extract<ColumnsOf<S, TN>[number], {
   name: K;
 }>> }>;
@@ -324,15 +473,15 @@ type WhereForTable<S extends DBSchema, TN extends string> = Partial<{ [K in Colu
   name: K;
 }>>[] }>;
 type WhereOperator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "like" | "ilike" | "notlike" | "notilike" | "in" | "notin" | "isnull" | "notnull";
-type OpPredicateForCol<S extends DBSchema, TN extends string, K extends ColumnNames<S, TN>> = readonly [K, "isnull" | "notnull"] | readonly [K, "like" | "ilike" | "notlike" | "notilike", string] | readonly [K, "in" | "notin", ReadonlyArray<ColumnValueFor<S, TN, K>>] | readonly [K, "=" | "!=" | "<" | "<=" | ">" | ">=", ColumnValueFor<S, TN, K>];
+type OpPredicateForCol<S extends DBSchema, TN extends string, K$1 extends ColumnNames<S, TN>> = readonly [K$1, "isnull" | "notnull"] | readonly [K$1, "like" | "ilike" | "notlike" | "notilike", string] | readonly [K$1, "in" | "notin", ReadonlyArray<ColumnValueFor<S, TN, K$1>>] | readonly [K$1, "=" | "!=" | "<" | "<=" | ">" | ">=", ColumnValueFor<S, TN, K$1>];
 type OpPredicate<S extends DBSchema, TN extends string> = { [K in ColumnNames<S, TN>]: OpPredicateForCol<S, TN, K> }[ColumnNames<S, TN>];
 type IsAny<T> = 0 extends (1 & T) ? true : false;
-type OpArgsFor<S extends DBSchema, TN extends string, K extends ColumnNames<S, TN>, O extends WhereOperator> = IsAny<O> extends true ? never[] : O extends "isnull" | "notnull" ? [] : O extends "like" | "ilike" | "notlike" | "notilike" ? [value: string] : O extends "in" | "notin" ? [value: ReadonlyArray<ColumnValueFor<S, TN, K>>] : O extends "=" | "!=" | "<" | "<=" | ">" | ">=" ? [value: ColumnValueFor<S, TN, K>] : never[];
+type OpArgsFor<S extends DBSchema, TN extends string, K$1 extends ColumnNames<S, TN>, O extends WhereOperator> = IsAny<O> extends true ? never[] : O extends "isnull" | "notnull" ? [] : O extends "like" | "ilike" | "notlike" | "notilike" ? [value: string] : O extends "in" | "notin" ? [value: ReadonlyArray<ColumnValueFor<S, TN, K$1>>] : O extends "=" | "!=" | "<" | "<=" | ">" | ">=" ? [value: ColumnValueFor<S, TN, K$1>] : never[];
 interface SqlBuilder<S extends DBSchema> {
   table: <TN extends TableNames<S>>(name: TN) => TableQuery<S, TN>;
 }
 type RowForTable<S extends DBSchema, TN extends string> = { [K in ColumnNames<S, TN>]: ColumnValueFor<S, TN, K> };
-type PickRow<S extends DBSchema, TN extends string, C extends ReadonlyArray<ColumnNames<S, TN>>> = { [K in C[number]]: ColumnValueFor<S, TN, K> };
+type PickRow<S extends DBSchema, TN extends string, C$1 extends ReadonlyArray<ColumnNames<S, TN>>> = { [K in C$1[number]]: ColumnValueFor<S, TN, K> };
 type RowOfSelect<Q> = Q extends {
   toSql: () => TypedSqlRequest<infer R>;
 } ? R : never;
@@ -341,67 +490,663 @@ type RowOfRequest<Rq> = Rq extends TypedSqlRequest<infer R> ? R : never;
 type RowsOfRequest<Rq> = RowOfRequest<Rq>[];
 interface TableQuery<S extends DBSchema, TN extends string> {
   select(): SelectQuery<S, TN, RowForTable<S, TN>>;
-  select<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): SelectQuery<S, TN, PickRow<S, TN, C>>;
+  select<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): SelectQuery<S, TN, PickRow<S, TN, C$1>>;
   insert: (values: ValuesForTable<S, TN>) => InsertQuery<S, TN>;
   update: (values: Partial<ValuesForTable<S, TN>>) => UpdateQuery<S, TN>;
   delete: () => DeleteQuery<S, TN>;
 }
-interface SelectQuery<S extends DBSchema, TN extends string, R extends DataRow> {
-  selectFrom: <JT extends TableNames<S>>(table: JT, cols?: ReadonlyArray<ColumnNames<S, JT>>) => SelectQuery<S, TN, R>;
-  andWhere: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R>;
+interface SelectQuery<S extends DBSchema, TN extends string, R$1 extends DataRow> {
+  selectFrom: <JT extends TableNames<S>>(table: JT, cols?: ReadonlyArray<ColumnNames<S, JT>>) => SelectQuery<S, TN, R$1>;
+  andWhere: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R$1>;
   /** @deprecated Use andWhere() instead */
-  where: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R>;
-  orWhere: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R>;
-  wherePk: (pk: PrimaryKeyValue<S, TN>) => SelectQuery<S, TN, R>;
-  andWhereOp<K extends ColumnNames<S, TN>, O extends WhereOperator>(col: K, op: O, ...args: OpArgsFor<S, TN, K, O>): SelectQuery<S, TN, R>;
-  orWhereOp<K extends ColumnNames<S, TN>, O extends WhereOperator>(col: K, op: O, ...args: OpArgsFor<S, TN, K, O>): SelectQuery<S, TN, R>;
-  andWhereOpGroup: (predicates: ReadonlyArray<OpPredicate<S, TN>>) => SelectQuery<S, TN, R>;
-  orWhereOpGroup: (predicates: ReadonlyArray<OpPredicate<S, TN>>) => SelectQuery<S, TN, R>;
-  orderBy: (order: ReadonlyArray<readonly [ColumnNames<S, TN>, "asc" | "desc"]> | ColumnNames<S, TN>) => SelectQuery<S, TN, R>;
-  limit: (n: number) => SelectQuery<S, TN, R>;
-  offset: (n: number) => SelectQuery<S, TN, R>;
-  join: <JT extends TableNames<S>>(table: JT, type?: "inner" | "left" | "right" | "full") => SelectQuery<S, TN, R>;
-  toSql: () => TypedSqlRequest<R>;
-}
-interface InsertReturningQuery<S extends DBSchema, TN extends string, R extends DataRow> {
+  where: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R$1>;
+  orWhere: (where: WhereForTable<S, TN>) => SelectQuery<S, TN, R$1>;
+  wherePk: (pk: PrimaryKeyValue<S, TN>) => SelectQuery<S, TN, R$1>;
+  andWhereOp<K$1 extends ColumnNames<S, TN>, O extends WhereOperator>(col: K$1, op: O, ...args: OpArgsFor<S, TN, K$1, O>): SelectQuery<S, TN, R$1>;
+  orWhereOp<K$1 extends ColumnNames<S, TN>, O extends WhereOperator>(col: K$1, op: O, ...args: OpArgsFor<S, TN, K$1, O>): SelectQuery<S, TN, R$1>;
+  andWhereOpGroup: (predicates: ReadonlyArray<OpPredicate<S, TN>>) => SelectQuery<S, TN, R$1>;
+  orWhereOpGroup: (predicates: ReadonlyArray<OpPredicate<S, TN>>) => SelectQuery<S, TN, R$1>;
+  orderBy: (order: ReadonlyArray<readonly [ColumnNames<S, TN>, "asc" | "desc"]> | ColumnNames<S, TN>) => SelectQuery<S, TN, R$1>;
+  limit: (n: number) => SelectQuery<S, TN, R$1>;
+  offset: (n: number) => SelectQuery<S, TN, R$1>;
+  join: <JT extends TableNames<S>>(table: JT, type?: "inner" | "left" | "right" | "full") => SelectQuery<S, TN, R$1>;
+  toSql: () => TypedSqlRequest<R$1>;
+}
+interface InsertReturningQuery<S extends DBSchema, TN extends string, R$1 extends DataRow> {
   returning(): InsertReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): InsertReturningQuery<S, TN, PickRow<S, TN, C>>;
-  toSql(): TypedSqlRequest<R>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): InsertReturningQuery<S, TN, PickRow<S, TN, C$1>>;
+  toSql(): TypedSqlRequest<R$1>;
 }
-interface UpdateReturningQuery<S extends DBSchema, TN extends string, R extends DataRow> {
-  where: (where: WhereForTable<S, TN>) => UpdateReturningQuery<S, TN, R>;
-  wherePk: (pk: PrimaryKeyValue<S, TN>) => UpdateReturningQuery<S, TN, R>;
+interface UpdateReturningQuery<S extends DBSchema, TN extends string, R$1 extends DataRow> {
+  where: (where: WhereForTable<S, TN>) => UpdateReturningQuery<S, TN, R$1>;
+  wherePk: (pk: PrimaryKeyValue<S, TN>) => UpdateReturningQuery<S, TN, R$1>;
   returning(): UpdateReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): UpdateReturningQuery<S, TN, PickRow<S, TN, C>>;
-  toSql(): TypedSqlRequest<R>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): UpdateReturningQuery<S, TN, PickRow<S, TN, C$1>>;
+  toSql(): TypedSqlRequest<R$1>;
 }
-interface DeleteReturningQuery<S extends DBSchema, TN extends string, R extends DataRow> {
-  where: (where: WhereForTable<S, TN>) => DeleteReturningQuery<S, TN, R>;
-  wherePk: (pk: PrimaryKeyValue<S, TN>) => DeleteReturningQuery<S, TN, R>;
+interface DeleteReturningQuery<S extends DBSchema, TN extends string, R$1 extends DataRow> {
+  where: (where: WhereForTable<S, TN>) => DeleteReturningQuery<S, TN, R$1>;
+  wherePk: (pk: PrimaryKeyValue<S, TN>) => DeleteReturningQuery<S, TN, R$1>;
   returning(): DeleteReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): DeleteReturningQuery<S, TN, PickRow<S, TN, C>>;
-  toSql(): TypedSqlRequest<R>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): DeleteReturningQuery<S, TN, PickRow<S, TN, C$1>>;
+  toSql(): TypedSqlRequest<R$1>;
 }
 interface InsertQuery<S extends DBSchema, TN extends string> {
   returning(): InsertReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): InsertReturningQuery<S, TN, PickRow<S, TN, C>>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): InsertReturningQuery<S, TN, PickRow<S, TN, C$1>>;
   toSql(): SqlRequest<Record<string, unknown>>;
 }
 interface UpdateQuery<S extends DBSchema, TN extends string> {
   where: (where: WhereForTable<S, TN>) => UpdateQuery<S, TN>;
   wherePk: (pk: PrimaryKeyValue<S, TN>) => UpdateQuery<S, TN>;
   returning(): UpdateReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): UpdateReturningQuery<S, TN, PickRow<S, TN, C>>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): UpdateReturningQuery<S, TN, PickRow<S, TN, C$1>>;
   toSql(): SqlRequest<Record<string, unknown>>;
 }
 interface DeleteQuery<S extends DBSchema, TN extends string> {
   where: (where: WhereForTable<S, TN>) => DeleteQuery<S, TN>;
   wherePk: (pk: PrimaryKeyValue<S, TN>) => DeleteQuery<S, TN>;
   returning(): DeleteReturningQuery<S, TN, RowForTable<S, TN>>;
-  returning<C extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C): DeleteReturningQuery<S, TN, PickRow<S, TN, C>>;
+  returning<C$1 extends ReadonlyArray<ColumnNames<S, TN>>>(cols: C$1): DeleteReturningQuery<S, TN, PickRow<S, TN, C$1>>;
   toSql(): SqlRequest<Record<string, unknown>>;
 }
 declare function createSqlBuilder<S extends DBSchema>(schema: S): SqlBuilder<S>;
 //#endregion
-export { Claims, CodeFlow, type CodeFlowOptions, type ColumnDef, type DBSchema, Meta, type Options, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type pgTypes_d_exports as PgTypes, type PickRow, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcRequest, type RpcResponse, SignUp, Sql, Stats, Status, type TableDef, Tables, Users, Ws, createApi, createSqlBuilder };
+//#region src/http/errors.d.ts
+/**
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ */
+interface CentiaApiErrorOptions {
+  message: string;
+  status?: number;
+  code?: string;
+  details?: unknown;
+  requestId?: string;
+  method: string;
+  url: string;
+  cause?: unknown;
+}
+/**
+ * Normalized error thrown by all SDK HTTP operations.
+ * CLI and Web should catch this type for consistent error handling.
+ */
+declare class CentiaApiError extends Error {
+  readonly name = "CentiaApiError";
+  readonly status: number | undefined;
+  readonly code: string | undefined;
+  readonly details: unknown;
+  readonly requestId: string | undefined;
+  readonly method: string;
+  readonly url: string;
+  constructor(opts: CentiaApiErrorOptions);
+}
+/** Type guard for CentiaApiError. */
+declare function isCentiaApiError(e: unknown): e is CentiaApiError;
+//#endregion
+//#region src/provisioning/types.d.ts
+/**
+ * @author     Martin Høgh <mh@mapcentia.com>
+ * @copyright  2013-2026 MapCentia ApS
+ * @license    https://opensource.org/license/mit  The MIT License
+ */
+type ConstraintType = 'primary' | 'foreign' | 'unique' | 'check';
+type IndexMethod = 'btree' | 'brin' | 'gin' | 'gist' | 'hash';
+type IdentityGeneration = 'always' | 'by default';
+type SequenceDataType = 'smallint' | 'integer' | 'bigint';
+interface LocationResponse {
+  location: string;
+}
+interface CreateSchemaRequest {
+  name: string;
+  tables?: TableDef$1[];
+  sequences?: SequenceDef[];
+}
+interface RenameSchemaRequest {
+  name: string;
+}
+interface GetSchemaOptions {
+  namesOnly?: boolean;
+}
+interface SchemaInfo {
+  name: string;
+  tables?: TableInfo[];
+  sequences?: SequenceInfo[];
+}
+interface TableDef$1 {
+  name: string;
+  columns?: ColumnDef$1[];
+  constraints?: ConstraintDef[];
+  indices?: IndexDef[];
+  comment?: string;
+}
+interface TableInfo {
+  name: string;
+  columns?: ColumnInfo[];
+  constraints?: ConstraintInfo[];
+  indices?: IndexInfo[];
+  comment?: string;
+}
+interface ColumnDef$1 {
+  name?: string;
+  type?: string;
+  is_nullable?: boolean;
+  default_value?: string;
+  identity_generation?: IdentityGeneration;
+  comment?: string;
+}
+interface CreateColumnRequest {
+  name: string;
+  type: string;
+  is_nullable?: boolean;
+  default_value?: string;
+  identity_generation?: IdentityGeneration;
+  comment?: string;
+}
+interface PatchColumnRequest {
+  name?: string;
+  type?: string;
+  is_nullable?: boolean;
+  default_value?: string;
+  identity_generation?: IdentityGeneration;
+  comment?: string;
+}
+interface ColumnInfo {
+  name: string;
+  type: string;
+  is_nullable: boolean;
+  default_value: string | null;
+  identity_generation?: string | null;
+  comment?: string | null;
+  _num?: number;
+  _typname?: string;
+  _is_array?: boolean;
+  _character_maximum_length?: number | null;
+  _numeric_precision?: number | null;
+  _numeric_scale?: number | null;
+  _max_bytes?: number;
+  _reference?: string[] | null;
+  _is_unique?: boolean;
+  _is_primary?: boolean;
+  _index_method?: string[] | null;
+  _checks?: unknown[] | null;
+}
+interface ConstraintDef {
+  constraint: ConstraintType;
+  columns: string[];
+  name?: string;
+  check?: string;
+  referenced_table?: string;
+  referenced_columns?: string[];
+}
+interface CreateConstraintRequest {
+  constraint: ConstraintType;
+  columns: string[];
+  name?: string;
+  check?: string;
+  referenced_table?: string;
+  referenced_columns?: string[];
+}
+interface ConstraintInfo {
+  name: string;
+  constraint: ConstraintType;
+  columns: string[];
+  referenced_table?: string;
+  referenced_columns?: string[];
+  check?: string;
+}
+interface IndexDef {
+  columns: string[];
+  method?: IndexMethod;
+  name?: string;
+}
+interface CreateIndexRequest {
+  columns: string[];
+  method?: IndexMethod;
+  name?: string;
+}
+interface IndexInfo {
+  name: string;
+  method: IndexMethod;
+  columns: string[];
+  unique?: boolean;
+}
+interface SequenceDef {
+  name: string;
+  data_type?: SequenceDataType;
+  increment_by?: number;
+  min_value?: number;
+  max_value?: number;
+  start_value?: number;
+  cache_size?: number;
+  owned_by?: string;
+}
+interface CreateSequenceRequest {
+  name: string;
+  data_type?: SequenceDataType;
+  increment_by?: number;
+  min_value?: number;
+  max_value?: number;
+  start_value?: number;
+  cache_size?: number;
+  owned_by?: string;
+}
+interface PatchSequenceRequest {
+  name: string;
+  data_type?: SequenceDataType;
+  increment_by?: number;
+  min_value?: number;
+  max_value?: number;
+  start_value?: number;
+  cache_size?: number;
+  owned_by?: string;
+}
+interface SequenceInfo {
+  name: string;
+  data_type: SequenceDataType;
+  increment_by: number;
+  min_value: number;
+  max_value: number;
+  start_value: number;
+  cache_size: number;
+  owned_by?: string;
+}
+interface CreateUserRequest {
+  name: string;
+  email: string;
+  password: string;
+  default_user?: boolean;
+  properties?: unknown;
+}
+interface PatchUserRequest {
+  email: string;
+  password: string | null;
+  default_user?: boolean;
+  properties?: unknown;
+  user_group?: string;
+}
+interface UserInfo {
+  name: string;
+  email: string;
+  default_user: boolean;
+  user_group?: string;
+  properties?: unknown;
+}
+interface CreateClientRequest {
+  name: string;
+  id?: string;
+  description?: string | null;
+  redirect_uri?: string[];
+  homepage?: string;
+  public?: boolean;
+  confirm?: boolean;
+  two_factor?: boolean;
+  allow_signup?: boolean;
+  social_signup?: boolean;
+}
+interface PatchClientRequest {
+  name?: string;
+  description?: string | null;
+  redirect_uri?: string[];
+  homepage?: string;
+  public?: boolean;
+  confirm?: boolean;
+  two_factor?: boolean;
+  allow_signup?: boolean;
+  social_signup?: boolean;
+}
+interface CreateClientResponse {
+  location: string;
+  secret: string;
+}
+interface ClientInfo {
+  id: string;
+  name: string;
+  description: string | null;
+  redirect_uri: string[];
+  homepage: string;
+  public: boolean;
+  confirm: boolean;
+  two_factor: boolean;
+  allow_signup: boolean;
+  social_signup: boolean;
+}
+type RuleAccess = 'allow' | 'limit' | 'deny';
+type RuleRequest = 'select' | 'insert' | 'update' | 'delete';
+type RuleService = 'sql' | 'ows' | 'wfst';
+interface CreateRuleRequest {
+  access?: RuleAccess;
+  filter?: string;
+  id?: number;
+  iprange?: string;
+  priority?: number;
+  request?: RuleRequest;
+  schema?: string;
+  service?: RuleService;
+  table?: string;
+  username?: string;
+}
+interface PatchRuleRequest {
+  access?: RuleAccess;
+  filter?: string;
+  iprange?: string;
+  priority?: number;
+  request?: RuleRequest;
+  schema?: string;
+  service?: RuleService;
+  table?: string;
+  username?: string;
+}
+interface RuleInfo {
+  id: number;
+  access?: RuleAccess;
+  filter?: string;
+  iprange?: string;
+  priority?: number;
+  request?: RuleRequest;
+  schema?: string;
+  service?: RuleService;
+  table?: string;
+  username?: string;
+}
+type PrivilegeLevel = 'none' | 'read' | 'write';
+interface PatchPrivilegeRequest {
+  subuser: string;
+  privilege: PrivilegeLevel;
+}
+interface PrivilegeInfo {
+  subuser: string;
+  privilege: PrivilegeLevel;
+}
+interface CreateRpcMethodRequest {
+  method: string;
+  q: string;
+  output_format?: string;
+  srs?: number;
+  type_formats?: Record<string, unknown>;
+  type_hints?: Record<string, unknown>;
+}
+interface PatchRpcMethodRequest {
+  q: string;
+  output_format?: string;
+  srs?: number;
+  type_formats?: Record<string, unknown>;
+  type_hints?: Record<string, unknown>;
+}
+interface RpcMethodInfo {
+  method: string;
+  q: string;
+  output_format?: string;
+  srs?: number;
+  type_formats?: Record<string, unknown>;
+  type_hints?: Record<string, unknown>;
+}
+interface MetadataFieldInfo {
+  alias?: string;
+  queryable?: boolean;
+  sort_id?: number;
+}
+interface MetadataRelationInfo {
+  title?: string;
+  abstract?: string;
+  group?: string;
+  sort_id?: number;
+  tags?: string[];
+  properties?: Record<string, unknown>;
+  fields?: Record<string, MetadataFieldInfo>;
+}
+interface PatchMetadataRequest {
+  relations: Record<string, MetadataRelationInfo>;
+}
+interface FileProcessRequest {
+  file: string;
+  schema: string;
+  import?: boolean;
+  append?: boolean;
+  truncate?: boolean;
+  p_multi?: boolean;
+  s_srs?: string;
+  t_srs?: string;
+  timestamp?: string;
+  x_possible_names?: string;
+  y_possible_names?: string;
+}
+interface FileProcessResult {
+  [key: string]: unknown;
+}
+interface CommitRequest {
+  schema: string;
+  repo: string;
+  message: string;
+  meta_query?: string;
+}
+interface CommitResult {
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/provisioning/Schemas.d.ts
+declare class Schemas {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getSchema(schema?: undefined, opts?: GetSchemaOptions): Promise<SchemaInfo[]>;
+  getSchema(schema: string, opts?: GetSchemaOptions): Promise<SchemaInfo>;
+  postSchema(body: CreateSchemaRequest): Promise<LocationResponse>;
+  patchSchema(schema: string, body: RenameSchemaRequest): Promise<LocationResponse>;
+  deleteSchema(schema: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Columns.d.ts
+declare class Columns {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  getColumn(schema: string, table: string): Promise<ColumnInfo[]>;
+  getColumn(schema: string, table: string, column: string): Promise<ColumnInfo>;
+  postColumn(schema: string, table: string, body: CreateColumnRequest): Promise<LocationResponse>;
+  patchColumn(schema: string, table: string, column: string, body: PatchColumnRequest): Promise<LocationResponse>;
+  deleteColumn(schema: string, table: string, column: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Constraints.d.ts
+declare class Constraints {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  getConstraint(schema: string, table: string): Promise<ConstraintInfo[]>;
+  getConstraint(schema: string, table: string, constraint: string): Promise<ConstraintInfo>;
+  postConstraint(schema: string, table: string, body: CreateConstraintRequest): Promise<LocationResponse>;
+  deleteConstraint(schema: string, table: string, constraint: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Indices.d.ts
+declare class Indices {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  getIndex(schema: string, table: string): Promise<IndexInfo[]>;
+  getIndex(schema: string, table: string, index: string): Promise<IndexInfo>;
+  postIndex(schema: string, table: string, body: CreateIndexRequest): Promise<LocationResponse>;
+  deleteIndex(schema: string, table: string, index: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Sequences.d.ts
+declare class Sequences {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  getSequence(schema: string): Promise<SequenceInfo[]>;
+  getSequence(schema: string, sequence: string): Promise<SequenceInfo>;
+  postSequence(schema: string, body: CreateSequenceRequest): Promise<LocationResponse>;
+  patchSequence(schema: string, sequence: string, body: PatchSequenceRequest): Promise<LocationResponse>;
+  deleteSequence(schema: string, sequence: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Tables.d.ts
+declare class ProvisioningTables {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private basePath;
+  getTable(schema: string): Promise<TableInfo[]>;
+  getTable(schema: string, table: string): Promise<TableInfo>;
+  postTable(schema: string, body: {
+    name: string;
+    [key: string]: unknown;
+  }): Promise<LocationResponse>;
+  patchTable(schema: string, table: string, body: Record<string, unknown>): Promise<LocationResponse>;
+  deleteTable(schema: string, table: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Users.d.ts
+declare class ProvisioningUsers {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getUser(): Promise<UserInfo[]>;
+  getUser(name: string): Promise<UserInfo>;
+  postUser(body: CreateUserRequest): Promise<LocationResponse>;
+  patchUser(name: string, body: PatchUserRequest): Promise<LocationResponse>;
+  deleteUser(name: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Clients.d.ts
+declare class ProvisioningClients {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getClient(): Promise<ClientInfo[]>;
+  getClient(id: string): Promise<ClientInfo>;
+  postClient(body: CreateClientRequest): Promise<CreateClientResponse>;
+  patchClient(id: string, body: PatchClientRequest): Promise<LocationResponse>;
+  deleteClient(id: string): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Rules.d.ts
+declare class Rules {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getRule(): Promise<RuleInfo[]>;
+  getRule(id: number): Promise<RuleInfo>;
+  postRule(body: CreateRuleRequest): Promise<RuleInfo>;
+  patchRule(id: number, body: PatchRuleRequest): Promise<RuleInfo>;
+  deleteRule(id: number): Promise<void>;
+}
+//#endregion
+//#region src/provisioning/Privileges.d.ts
+declare class Privileges {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getPrivileges(schema: string, table: string): Promise<PrivilegeInfo[]>;
+  patchPrivileges(schema: string, table: string, body: PatchPrivilegeRequest): Promise<PrivilegeInfo[]>;
+}
+//#endregion
+//#region src/provisioning/RpcMethods.d.ts
+declare class RpcMethods {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getRpc(): Promise<RpcMethodInfo[]>;
+  getRpc(method: string): Promise<RpcMethodInfo>;
+  postRpc(body: CreateRpcMethodRequest): Promise<LocationResponse>;
+  patchRpc(method: string, body: PatchRpcMethodRequest): Promise<LocationResponse>;
+  deleteRpc(method: string): Promise<void>;
+  postCallDry(body: unknown): Promise<unknown>;
+}
+//#endregion
+//#region src/provisioning/MetadataWrite.d.ts
+declare class MetadataWrite {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  patchMetaData(body: PatchMetadataRequest): Promise<unknown>;
+}
+//#endregion
+//#region src/provisioning/TypeScriptInterfaces.d.ts
+declare class TypeScriptInterfaces {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  getTypeScript(): Promise<string>;
+}
+//#endregion
+//#region src/provisioning/FileImport.d.ts
+declare class FileImport {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  /**
+   * Upload a file via multipart/form-data.
+   * In Node.js, pass a FormData instance. In browsers, pass a native FormData.
+   */
+  postFileUpload(formData: FormData): Promise<{
+    filename: string;
+  }>;
+  postFileProcess(body: FileProcessRequest): Promise<FileProcessResult>;
+}
+//#endregion
+//#region src/provisioning/GitCommit.d.ts
+declare class GitCommit {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  postCommit(body: CommitRequest): Promise<CommitResult>;
+}
+//#endregion
+//#region src/provisioning/SqlNoToken.d.ts
+interface SqlNoTokenRequest {
+  q: string;
+  output_format?: string;
+  srs?: number;
+  params?: Record<string, unknown>[];
+  type_formats?: Record<string, unknown>;
+  type_hints?: Record<string, unknown>;
+}
+declare class SqlNoToken {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  postSqlNoToken(database: string, body: SqlNoTokenRequest): Promise<unknown>;
+}
+//#endregion
+//#region src/admin.d.ts
+/** Admin client providing access to all provisioning operations. */
+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. */
+  readonly provisioning: {
+    readonly schemas: Schemas;
+    readonly tables: ProvisioningTables;
+    readonly columns: Columns;
+    readonly constraints: Constraints;
+    readonly indices: Indices;
+    readonly sequences: Sequences;
+    readonly users: ProvisioningUsers;
+    readonly clients: ProvisioningClients;
+    readonly rules: Rules;
+    readonly privileges: Privileges;
+    readonly rpcMethods: RpcMethods;
+    readonly metadata: MetadataWrite;
+    readonly typeScript: TypeScriptInterfaces;
+    readonly fileImport: FileImport;
+    readonly gitCommit: GitCommit;
+    readonly sqlNoToken: SqlNoToken;
+  };
+}
+/**
+ * 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' });
+ * ```
+ */
+declare function createCentiaAdminClient(config: CentiaClientConfig): CentiaAdminClient;
+//#endregion
+//#region src/index.d.ts
+/**
+* @author     Martin Høgh <mh@mapcentia.com>
+* @copyright  2013-2026 MapCentia ApS
+* @license    https://opensource.org/license/mit  The MIT License
+*
+*/
+
+//#endregion
+export { 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 CreateIndexRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateUserRequest, type DBSchema, type FileProcessRequest, type FileProcessResult, type FullResponse, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, type LocationResponse, Meta, type MetadataFieldInfo, type MetadataRelationInfo, type Options, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, 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, SignUp, Sql, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type TableDef, type TableInfo, Tables, type UserInfo, Users, Ws, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, isCentiaApiError };
 //# sourceMappingURL=centia-io-sdk.d.ts.map