@oino-ts/types 0.21.2 → 1.0.0

package/blob/src/OINOBlob.d.ts

@@ -0,0 +1,78 @@
+import { OINODataSource, OINODataCell, OINOQueryFilter } from "@oino-ts/common";
+import { OINOBlobParams, OINOBlobEntry, OINOBlobFetchResult } from "./OINOBlobConstants.js";
+/**
+ * Abstract base class for blob storage backends.  Subclasses implement
+ * the two core operations (`listEntries` and `fetchEntry`) for a specific
+ * provider (e.g. Azure Blob Storage, S3, …).
+ *
+ * The SQL-formatting methods inherited from `OINODataSource` are not used
+ * by blob operations; they are implemented here as passthrough stubs so
+ * that the blob datasource can still be composed with `OINODataField`.
+ */
+export declare abstract class OINOBlob extends OINODataSource {
+    protected readonly blobParams: OINOBlobParams;
+    /** Container / bucket name */
+    readonly name: string;
+    /**
+     * Constructor for `OINOBlob`.
+     * @param params blob storage connection parameters
+     */
+    constructor(params: OINOBlobParams);
+    printTableName(name: string): string;
+    printColumnName(name: string): string;
+    printCellAsValue(cellValue: OINODataCell, _sqlType: string): string;
+    printStringValue(s: string): string;
+    parseValueAsCell(v: OINODataCell, nativeType: string): OINODataCell;
+    /**
+     * Test whether a blob entry matches an `OINOQueryFilter` predicate.
+     * Used for in-memory (result) filtering when the storage backend cannot
+     * translate the predicate to a native query.
+     *
+     * @param entry blob entry to test
+     * @param filter filter predicate to evaluate
+     */
+    protected static matchesEntry(entry: OINOBlobEntry, filter: OINOQueryFilter): boolean;
+    /**
+     * Extract a blob/object name prefix from the filter that can be forwarded
+     * to the storage backend as a server-side query optimisation.
+     *
+     * Only two cases translate to a prefix:
+     * - `(name)-eq(value)`        → exact name match (use as prefix)
+     * - `(name)-like(prefix%)`    → trailing-wildcard prefix match
+     *
+     * AND-combined filters are explored recursively so that a name constraint
+     * nested inside a larger AND predicate is still extracted.
+     *
+     * @param filter filter to inspect
+     */
+    protected static extractNamePrefix(filter: OINOQueryFilter): string | undefined;
+    /**
+     * List blob entries, optionally filtered by a query filter.  Implementations
+     * should apply native query filtering where possible and fall back to
+     * in-memory result filtering for predicates that cannot be expressed as a
+     * native query.
+     *
+     * @param filter optional query filter to apply to the results
+     */
+    abstract listEntries(filter?: OINOQueryFilter): Promise<OINOBlobEntry[]>;
+    /**
+     * Fetch the binary content and content-type of a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    abstract fetchEntry(name: string): Promise<OINOBlobFetchResult>;
+    /**
+     * Upload (create or replace) a blob with the given binary content.
+     *
+     * @param name full blob name (path within the container)
+     * @param content binary content to store
+     * @param contentType MIME type of the content (e.g. `"image/jpeg"`)
+     */
+    abstract uploadEntry(name: string, content: Uint8Array, contentType: string): Promise<void>;
+    /**
+     * Delete a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    abstract deleteEntry(name: string): Promise<void>;
+}

package/blob/src/OINOBlobApi.d.ts

@@ -0,0 +1,49 @@
+import { OINOApi, OINOApiParams, OINOApiRequest, OINOApiResult, OINOModelSet, OINOContentType, OINOQueryParams, OINOHttpRequest, type OINOApiData } from "@oino-ts/common";
+import { OINOBlob } from "./OINOBlob.js";
+import { OINOBlobDataModel } from "./OINOBlobDataModel.js";
+export declare class OINOBlobApiResult extends OINOApiResult {
+    /** Binary content of the blob (for GET with id) */
+    blobData?: Uint8Array;
+    /** Content-Type of the blob (for GET with id) */
+    blobDataType?: string;
+    constructor(request: OINOApiRequest, data?: OINOModelSet, blobData?: Uint8Array, blobDataType?: string);
+    writeApiResponse(headers?: Record<string, string>): Promise<Response>;
+}
+/**
+ * REST API for blob storage.
+ *
+ * Supports two GET variants:
+ * - **GET without id** – lists all blobs under the configured prefix and
+ *   returns the metadata as JSON (or CSV) using `OINOModelSet`.
+ * - **GET with id** – downloads the named blob as a binary HTTP response
+ *   with the blob's own `Content-Type`.
+ *
+ * All other HTTP methods return `405 Method Not Allowed`.
+ */
+export declare class OINOBlobApi extends OINOApi {
+    /** Blob storage backend */
+    readonly blob: OINOBlob;
+    /** Blob-specific data model (populated by `initializeDatamodel`) */
+    blobDatamodel: OINOBlobDataModel | null;
+    /**
+     * Constructor.
+     *
+     * NOTE: `initializeDatamodel` (or `OINOBlobFactory.createApi`) must be
+     * called before the first request is dispatched.
+     *
+     * @param blob blob storage backend
+     * @param params API parameters (`tableName` is used as the blob prefix)
+     */
+    constructor(blob: OINOBlob, params: OINOApiParams);
+    /**
+     * Attach the static blob data model and mark the API as initialised.
+     *
+     * @param datamodel `OINOBlobDataModel` instance for this API
+     */
+    initializeDatamodel(datamodel: OINOBlobDataModel): void;
+    doApiRequest(request: OINOApiRequest): Promise<OINOBlobApiResult>;
+    doHttpRequest(request: OINOHttpRequest, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams): Promise<OINOBlobApiResult>;
+    doRequest(method: string, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams, contentType?: OINOContentType): Promise<OINOBlobApiResult>;
+    doBatchUpdate(method: string, _rowId: string, _rowData: OINOApiData, _queryParams?: OINOQueryParams): Promise<OINOBlobApiResult>;
+    doBatchApiRequest(request: OINOApiRequest): Promise<OINOBlobApiResult>;
+}

package/blob/src/OINOBlobConstants.d.ts

@@ -0,0 +1,37 @@
+import type { OINOBlob } from "./OINOBlob.js";
+/**
+ * Blob class (constructor) type
+ * @param params blob parameters
+ */
+export type OINOBlobConstructor = new (params: OINOBlobParams) => OINOBlob;
+/** Blob storage connection parameters */
+export type OINOBlobParams = {
+    /** Name of the blob class (e.g. OINOBlobAzureTable) */
+    type: string;
+    /** Blob service endpoint URL */
+    url: string;
+    /** Container / bucket name */
+    container: string;
+    /** Provider-specific connection string (e.g. Azure Storage connection string or SAS URL) */
+    connectionStr?: string;
+};
+/** A single blob entry returned by a listing operation */
+export type OINOBlobEntry = {
+    /** Full blob name (path within the container) */
+    name: string;
+    /** Entity tag */
+    etag: string;
+    /** Last modification timestamp */
+    lastModified: Date;
+    /** Size in bytes */
+    contentLength: number;
+    /** MIME content type */
+    contentType: string;
+};
+/** Result of a blob fetch operation */
+export type OINOBlobFetchResult = {
+    /** Raw blob bytes */
+    content: Uint8Array;
+    /** MIME content type of the blob */
+    contentType: string;
+};

package/blob/src/OINOBlobDataModel.d.ts

@@ -0,0 +1,33 @@
+import { OINODataModel, OINOMemoryDataset } from "@oino-ts/common";
+import { OINOBlobApi } from "./OINOBlobApi.js";
+import { OINOBlobEntry } from "./OINOBlobConstants.js";
+/**
+ * Static data model for blob listings.
+ *
+ * Fields are added by the blob implementation's `initializeApiDatamodel`
+ * method, so the exact set depends on what the storage backend supports.
+ * The canonical order is:
+ *   1. `name`          – full blob name (primary key, string)
+ *   2. `etag`          – entity tag (string)
+ *   3. `lastModified`  – last modification timestamp (datetime)
+ *   4. `contentLength` – size in bytes (number)
+ *   5. `contentType`   – MIME type (string) – omitted when not supported
+ */
+export declare class OINOBlobDataModel extends OINODataModel {
+    /** Reference to the owning blob API */
+    readonly blobApi: OINOBlobApi;
+    /**
+     * Constructor.  Fields are added externally by the blob implementation
+     * via `initializeApiDatamodel`.
+     *
+     * @param api the `OINOBlobApi` that owns this data model
+     */
+    constructor(api: OINOBlobApi);
+    /**
+     * Convert an array of blob entries into an in-memory dataset whose
+     * columns match the fields present in this model.
+     *
+     * @param entries blob entries from the storage backend
+     */
+    entriesToDataset(entries: OINOBlobEntry[]): OINOMemoryDataset;
+}

package/blob/src/OINOBlobFactory.d.ts

@@ -0,0 +1,40 @@
+import { OINOApiParams } from "@oino-ts/common";
+import { OINOBlobParams, OINOBlobConstructor } from "./OINOBlobConstants.js";
+import { OINOBlob } from "./OINOBlob.js";
+import { OINOBlobApi } from "./OINOBlobApi.js";
+/**
+ * Static factory for creating `OINOBlob` instances and `OINOBlobApi` instances
+ * from registered provider classes.
+ *
+ * Usage:
+ * ```ts
+ * OINOBlobFactory.registerBlob("OINOBlobAzureTable", OINOBlobAzureTable)
+ * const blob = await OINOBlobFactory.createBlob({ type: "OINOBlobAzureTable", ... })
+ * const api  = await OINOBlobFactory.createApi(blob, { apiName: "files", tableName: "uploads/" })
+ * ```
+ */
+export declare class OINOBlobFactory {
+    private static _registry;
+    /**
+     * Register a blob provider class under the given name.
+     *
+     * @param name name used in `OINOBlobParams.type`
+     * @param blobClass constructor of the provider
+     */
+    static registerBlob(name: string, blobClass: OINOBlobConstructor): void;
+    /**
+     * Create and optionally connect/validate a blob backend from params.
+     *
+     * @param params connection parameters
+     * @param connect if true, calls `connect()` on the backend
+     * @param validate if true, calls `validate()` on the backend
+     */
+    static createBlob(params: OINOBlobParams, connect?: boolean, validate?: boolean): Promise<OINOBlob>;
+    /**
+     * Create an `OINOBlobApi` and initialise its data model.
+     *
+     * @param blob blob backend to use
+     * @param params API parameters (`tableName` is used as the blob prefix)
+     */
+    static createApi(blob: OINOBlob, params: OINOApiParams): Promise<OINOBlobApi>;
+}

package/blob/src/index.d.ts

@@ -0,0 +1,5 @@
+export { OINOBlob } from "./OINOBlob.js";
+export { OINOBlobDataModel } from "./OINOBlobDataModel.js";
+export { OINOBlobFactory } from "./OINOBlobFactory.js";
+export { OINOBlobApi, OINOBlobApiResult } from "./OINOBlobApi.js";
+export { type OINOBlobConstructor, type OINOBlobParams, type OINOBlobEntry, type OINOBlobFetchResult } from "./OINOBlobConstants.js";

package/blob-aws/src/OINOBlobAwsS3.d.ts

@@ -0,0 +1,90 @@
+import { OINOApi, OINOResult, OINOQueryFilter } from "@oino-ts/common";
+import { OINOBlob } from "@oino-ts/blob";
+import { type OINOBlobEntry, type OINOBlobFetchResult } from "@oino-ts/blob";
+/**
+ * AWS S3 (and S3-compatible) implementation of `OINOBlob`.
+ *
+ * Authenticates using static access key credentials supplied via a JSON-encoded
+ * connection string.  Connection parameters map as:
+ * - `params.url`           → optional custom endpoint, e.g. `https://s3.eu-west-1.amazonaws.com`
+ *                            or a compatible service such as MinIO / Cloudflare R2
+ * - `params.container`     → S3 bucket name
+ * - `params.connectionStr` → JSON string: `{"region":"…","accessKeyId":"…","secretAccessKey":"…"}`
+ *
+ * Register and use via the factory:
+ * ```ts
+ * import { OINOBlobFactory } from "@oino-ts/blob"
+ * import { OINOBlobAwsS3 }      from "@oino-ts/blob-aws"
+ *
+ * OINOBlobFactory.registerBlob("OINOBlobAwsS3", OINOBlobAwsS3)
+ *
+ * const blob = await OINOBlobFactory.createBlob({
+ *     type:          "OINOBlobAwsS3",
+ *     url:           "",                             // leave empty for default AWS endpoint
+ *     container:     "my-bucket",
+ *     connectionStr: JSON.stringify({
+ *         region:          "us-east-1",
+ *         accessKeyId:     process.env.AWS_ACCESS_KEY_ID,
+ *         secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+ *     })
+ * })
+ * ```
+ */
+export declare class OINOBlobAwsS3 extends OINOBlob {
+    private _s3Client;
+    /**
+     * Initialise the AWS SDK S3 client from the JSON-encoded `connectionStr`.
+     * Does not perform any network call.
+     */
+    connect(): Promise<OINOResult>;
+    /**
+     * Verify that the target bucket exists and is accessible using a `HeadBucket` call.
+     */
+    validate(): Promise<OINOResult>;
+    /**
+     * Release the S3 client (destroys the underlying HTTP connection pool).
+     */
+    disconnect(): Promise<void>;
+    /**
+     * List all objects in the bucket, applying a server-side S3 `Prefix` filter
+     * where possible and in-memory result filtering for all other predicates.
+     *
+     * - The `name` field supports server-side prefix filtering via `ListObjectsV2`
+     *   `Prefix` option (query filtering).
+     * - All other field predicates (`etag`, `lastModified`, `contentLength`,
+     *   `contentType`) are evaluated in-memory after the listing (result filtering).
+     *   Note: S3 listing does not return `contentType`; it defaults to
+     *   `"application/octet-stream"` unless a `contentType` filter is applied.
+     *
+     * @param filter optional query filter to apply
+     */
+    listEntries(filter?: OINOQueryFilter): Promise<OINOBlobEntry[]>;
+    /**
+     * Download the raw content of a named object.
+     *
+     * @param name full object key (path within the bucket)
+     */
+    fetchEntry(name: string): Promise<OINOBlobFetchResult>;
+    /**
+     * Upload (create or replace) an object with the given binary content.
+     *
+     * @param name full object key (path within the bucket)
+     * @param content binary content to store
+     * @param contentType MIME type of the content (e.g. `"image/jpeg"`)
+     */
+    uploadEntry(name: string, content: Uint8Array, contentType: string): Promise<void>;
+    /**
+     * Delete a named object.
+     *
+     * @param name full object key (path within the bucket)
+     */
+    deleteEntry(name: string): Promise<void>;
+    /**
+     * Attach a static `OINOBlobDataModel` to the given API, adding only the
+     * four fields that S3 object listings return (`contentType` is omitted
+     * because S3 does not include it in listing responses).
+     *
+     * @param api the `OINOBlobApi` whose data model is to be initialised
+     */
+    initializeApiDatamodel(api: OINOApi): Promise<void>;
+}

package/blob-aws/src/index.d.ts

@@ -0,0 +1 @@
+export { OINOBlobAwsS3 } from "./OINOBlobAwsS3.js";

package/blob-azure/src/OINOBlobAzureTable.d.ts

@@ -0,0 +1,86 @@
+import { OINOApi, OINOResult, OINOQueryFilter } from "@oino-ts/common";
+import { OINOBlob } from "@oino-ts/blob";
+import { type OINOBlobEntry, type OINOBlobFetchResult } from "@oino-ts/blob";
+/**
+ * Azure Blob Storage implementation of `OINOBlob`.
+ *
+ * Authenticates using an Azure Storage connection string.  Connection parameters map as:
+ * - `params.url`           → blob service endpoint, e.g. `https://<account>.blob.core.windows.net`
+ * - `params.container`     → container name
+ * - `params.connectionStr` → Azure Storage connection string (e.g. `DefaultEndpointsProtocol=https;AccountName=...`)
+ *
+ * Register and use via the factory:
+ * ```ts
+ * import { OINOBlobFactory } from "@oino-ts/blob"
+ * import { OINOBlobAzureTable }   from "@oino-ts/blob-azure"
+ *
+ * OINOBlobFactory.registerBlob("OINOBlobAzureTable", OINOBlobAzureTable)
+ *
+ * const blob = await OINOBlobFactory.createBlob({
+ *     type:          "OINOBlobAzureTable",
+ *     url:           "https://myaccount.blob.core.windows.net",
+ *     container:     "my-container",
+ *     connectionStr: process.env.AZURE_STORAGE_CONNECTION_STRING
+ * })
+ * const api = await OINOBlobFactory.createApi(blob, {
+ *     apiName:   "files",
+ *     tableName: "uploads/"   // blob prefix / folder
+ * })
+ * ```
+ */
+export declare class OINOBlobAzureTable extends OINOBlob {
+    private _containerClient;
+    /**
+     * Initialise the Azure SDK client.  Does not perform any network call.
+     */
+    connect(): Promise<OINOResult>;
+    /**
+     * Verify that the target container exists and is accessible.
+     */
+    validate(): Promise<OINOResult>;
+    /**
+     * Release the client reference (Azure SDK is stateless per-request so nothing to close).
+     */
+    disconnect(): Promise<void>;
+    /**
+     * List all blobs, applying native Azure query filtering where possible and
+     * in-memory result filtering for predicates that cannot be expressed as a
+     * native query.
+     *
+     * - The `name` field supports server-side prefix filtering via the Azure
+     *   `listBlobsFlat` `prefix` option (query filtering).
+     * - All other field predicates (`etag`, `lastModified`, `contentLength`,
+     *   `contentType`) are evaluated in-memory after the listing (result
+     *   filtering).
+     *
+     * @param filter optional query filter to apply
+     */
+    listEntries(filter?: OINOQueryFilter): Promise<OINOBlobEntry[]>;
+    /**
+     * Download the raw content of a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    fetchEntry(name: string): Promise<OINOBlobFetchResult>;
+    /**
+     * Upload (create or replace) a blob with the given binary content.
+     *
+     * @param name full blob name (path within the container)
+     * @param content binary content to store
+     * @param contentType MIME type of the content (e.g. `"image/jpeg"`)
+     */
+    uploadEntry(name: string, content: Uint8Array, contentType: string): Promise<void>;
+    /**
+     * Delete a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    deleteEntry(name: string): Promise<void>;
+    /**
+     * Attach a static `OINOBlobDataModel` to the given API, adding all five
+     * standard fields that Azure Blob Storage returns in a listing.
+     *
+     * @param api the `OINOBlobApi` whose data model is to be initialised
+     */
+    initializeApiDatamodel(api: OINOApi): Promise<void>;
+}

package/blob-azure/src/index.d.ts

@@ -0,0 +1 @@
+export { OINOBlobAzureTable } from "./OINOBlobAzureTable.js";

package/common/src/OINOApi.d.ts

@@ -0,0 +1,191 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from "node:buffer";
+import { OINOHashid } from "@oino-ts/hashid";
+import { OINOContentType, OINODataRow } from "./OINOConstants.js";
+import { OINODataSource } from "./OINODataSource.js";
+import { OINODataModel } from "./OINODataModel.js";
+import { OINOModelSet } from "./OINOModelSet.js";
+import { OINOQueryParams, OINOQueryFilter, OINOQueryOrder, OINOQueryAggregate, OINOQueryLimit, OINOQuerySelect } from "./OINOQueryParams.js";
+import { OINOHttpRequest, OINOHttpRequestInit } from "./OINORequest.js";
+import { OINOHttpResult, OINOResult } from "./OINOResult.js";
+import { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
+/** API parameters */
+export type OINOApiParams = {
+    /** Name of the api */
+    apiName: string;
+    /** Name of the database table */
+    tableName: string;
+    /** Reject values that exceed field max length (behaviour on such is platform dependent) */
+    failOnOversizedValues?: boolean;
+    /** Reject PUT-requests that contain values for autoinc-type fields */
+    failOnUpdateOnAutoinc?: boolean;
+    /** Reject POST-requests without primary key value (can work if DB-side ) */
+    failOnInsertWithoutKey?: boolean;
+    /** Reject POST-requests without primary key value (can work if DB-side ) */
+    failOnAnyInvalidRows?: boolean;
+    /** Treat date type fields as just strings and use the native formatting instead of the ISO 8601 format */
+    useDatesAsString?: boolean;
+    /** Include given fields from the API and exclude rest (if defined) */
+    includeFields?: string[];
+    /** Exclude all fields with this prefix from the API */
+    excludeFieldPrefix?: string;
+    /** Exclude given fields from the API and include rest (if defined) */
+    excludeFields?: string[];
+    /** Enable hashids for numeric primarykeys by adding a 32 char key */
+    hashidKey?: string;
+    /** Set (minimum) length (12-32 chars) of the hashids */
+    hashidLength?: number;
+    /** Make hashids static per row/table */
+    hashidStaticIds?: boolean;
+    /** Name of field that has the modified field */
+    cacheModifiedField?: string;
+    /** Return inserted id values */
+    returnInsertedIds?: boolean;
+};
+export type OINOApiData = string | OINODataRow[] | Buffer | Uint8Array | object | null;
+export interface OINOApiRequestInit extends OINOHttpRequestInit {
+    rowId?: string;
+    rowData?: OINOApiData;
+    queryParams?: OINOQueryParams;
+    filter?: OINOQueryFilter | string;
+    order?: OINOQueryOrder | string;
+    limit?: OINOQueryLimit | string;
+    aggregate?: OINOQueryAggregate | string;
+    select?: OINOQuerySelect | string;
+}
+export declare class OINOApiRequest extends OINOHttpRequest {
+    rowId: string;
+    rowData: OINOApiData;
+    queryParams: OINOQueryParams;
+    constructor(init: OINOApiRequestInit);
+    static fromFetchRequest(request: Request, rowId?: string, rowData?: OINOApiData, queryParams?: OINOQueryParams): Promise<OINOApiRequest>;
+    static fromHttpRequest(request: OINOHttpRequest, rowId?: string, rowData?: OINOApiData, queryParams?: OINOQueryParams): OINOApiRequest;
+}
+/**
+ * OINO API request result object with returned data and/or http status code/message and
+ * error / warning messages.
+ *
+ */
+export declare class OINOApiResult extends OINOResult {
+    /** DbApi request params */
+    request: OINOApiRequest;
+    /** Returned data if any */
+    data?: OINOModelSet;
+    /**
+     * Constructor of OINOApiResult.
+     *
+     * @param request DbApi request parameters
+     * @param data result data
+     *
+     */
+    constructor(request: OINOApiRequest, data?: OINOModelSet);
+    /**
+     * Creates a HTTP Response from API results.
+     *
+     * @param headers Headers to include in the response
+     *
+     */
+    writeApiResponse(headers?: Record<string, string>): Promise<Response>;
+}
+/**
+ * Specialized HTML template that can render ´OINOApiResult´.
+ *
+ */
+export declare class OINOApiHtmlTemplate extends OINOHtmlTemplate {
+    /** Locale validation regex */
+    static LOCALE_REGEX: RegExp;
+    /** Locale formatter */
+    protected _locale: Intl.DateTimeFormat | null;
+    protected _numberDecimals: number;
+    /**
+     * Constructor of OINOApiHtmlTemplate.
+     *
+     * @param template HTML template string
+     * @param numberDecimals Number of decimals to use for numbers, -1 for no formatting
+     * @param dateLocaleStr Datetime format string, either "iso" for ISO8601 or "default" for system default or valid locale string
+     * @param dateLocaleStyle Datetime format style, either "short/medium/long/full" or Intl.DateTimeFormat options
+     *
+     */
+    constructor(template: string, numberDecimals?: number, dateLocaleStr?: string, dateLocaleStyle?: string | any);
+    /**
+     * Creates HTML Response from API modelset.
+     *
+     * @param modelset OINO API dataset
+     * @param overrideValues values to override in the data
+     *
+     */
+    renderFromDbData(modelset: OINOModelSet, overrideValues?: any): Promise<OINOHttpResult>;
+}
+/**
+ * API class with method to process HTTP REST requests.
+ *
+ */
+export declare abstract class OINOApi {
+    /** Enable debug output on errors */
+    protected _debugOnError: boolean;
+    /** API database reference */
+    readonly datasource: OINODataSource;
+    /** API parameters */
+    readonly params: OINOApiParams;
+    /** API hashid */
+    readonly hashid: OINOHashid | null;
+    /** Is API initialized */
+    initialized: boolean;
+    /** API datamodel */
+    datamodel: OINODataModel | null;
+    constructor(datasource: OINODataSource, params: OINOApiParams);
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     *
+     * @param request OINO HTTP request object containing all parameters of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     *
+     */
+    abstract doHttpRequest(request: OINOHttpRequest, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams): Promise<OINOApiResult>;
+    /**
+     * Method for handling a HTTP REST request with GET, POST, PUT, DELETE corresponding to
+     * SQL select, insert, update and delete.
+     *
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     * @param queryParams SQL parameters for the REST request
+     * @param contentType content type of the HTTP body data, default is JSON
+     *
+     */
+    abstract doRequest(method: string, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams, contentType: OINOContentType): Promise<OINOApiResult>;
+    abstract doApiRequest(request: OINOApiRequest): Promise<OINOApiResult>;
+    /**
+     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
+     *
+     * @param method HTTP method of the REST request
+     * @param rowId URL id of the REST request
+     * @param rowData HTTP body data as either serialized string or unserialized JS object or OINODataRow-array or Buffer/Uint8Array binary data
+     *
+     */
+    abstract doBatchUpdate(method: string, rowId: string, rowData: OINOApiData, queryParams?: OINOQueryParams): Promise<OINOApiResult>;
+    /**
+     * Method for handling a HTTP REST request with batch update using PUT or DELETE methods.
+     *
+     * @param request HTTP URL parameters as key-value-pairs
+     *
+     */
+    abstract doBatchApiRequest(request: OINOApiRequest): Promise<OINOApiResult>;
+    /**
+     * Enable or disable debug output on errors.
+     *
+     * @param debugOnError true to enable debug output on errors, false to disable
+     */
+    setDebugOnError(debugOnError: boolean): void;
+    /**
+     * Method to check if a field is included in the API params.
+     *
+     * @param fieldName name of the field
+     *
+     */
+    isFieldIncluded(fieldName: string): boolean;
+}