@aerokit/sdk 12.44.0

package/dist/dts/db/insert.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Interface used to wrap complex or other specific values for database insertion.
+ */
+export interface InsertParameter {
+    readonly value: any;
+}
+/**
+ * Type alias for a single allowed parameter value in an INSERT statement.
+ */
+type ParameterValue = string | number | boolean | Date | InsertParameter;
+/**
+ * Provides static methods for executing INSERT SQL statements.
+ */
+export declare class Insert {
+    /**
+     * Executes a single parameterized INSERT statement.
+     * * @param sql The SQL query to execute, with '?' placeholders for parameters.
+     * @param parameters An optional array of values to replace the '?' placeholders.
+     * @param datasourceName The name of the database connection to use (optional).
+     * @returns An array of records representing the result of the insertion (e.g., generated keys).
+     */
+    static execute(sql: string, parameters?: ParameterValue[], datasourceName?: string): Array<Record<string, any>>;
+    /**
+     * Executes multiple parameterized INSERT statements as a batch operation.
+     * * @param sql The SQL query to execute, with '?' placeholders for parameters.
+     * @param parameters An optional array of parameter arrays, where each inner array corresponds to one execution of the SQL statement.
+     * @param datasourceName The name of the database connection to use (optional).
+     * @returns An array of records representing the results of the batched insertions.
+     */
+    static executeMany(sql: string, parameters?: ParameterValue[][], datasourceName?: string): Array<Record<string, any>>;
+}
+export {};

package/dist/dts/db/orm.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Supported ORM schema:
+ * ```
+ * {
+ *	 name: <string>,
+ *   table: <string>,
+ *   properties: [{
+ *	   name: <string>,
+ *	   column: <string>,
+ *	   id: <boolean>,
+ *	   required: <boolean>,
+ *	   unique: <boolean>,
+ *	   dbValue: <function>,
+ *	   value: <function>,
+ *	   allowedOps: <Array['insert','update']>
+ *   }],
+ * 	 associations: [{
+ *	   name: <string>,
+ *     joinKey: <string>,
+ *     key: <string>,
+ *     type: <ORM.ASSOCIATION_TYPES>,
+ *     targetDao: <function|DAO>,
+ *     joinDao: <function|DAO>,
+ *     defaults: <Object>,
+ *   }]
+ * }
+ * ```
+ *
+ */
+export interface ORMDefinition {
+    table: string;
+    properties: {
+        name: string;
+        column: string;
+        type: string;
+        id?: boolean;
+        required?: boolean;
+        unique?: boolean;
+        autoIncrement?: boolean;
+        allowedOps?: ('insert' | 'update')[];
+    }[];
+}
+export declare function ORM(orm: ORMDefinition): void;
+export declare function get(orm: ORMDefinition): any;

package/dist/dts/db/ormstatements.d.ts

@@ -0,0 +1,4 @@
+import { SQLBuilder } from "./sql";
+import { Connection } from "./database";
+export declare function ORMStatements(orm: any, dialect: SQLBuilder): void;
+export declare function create(orm: any, connection?: Connection): any;

package/dist/dts/db/procedure.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @interface ProcedureParameter
+ * @description Defines a structured parameter for procedure calls, allowing the type
+ * to be explicitly defined when the natural JavaScript type mapping is insufficient.
+ */
+export interface ProcedureParameter {
+    type: string;
+    value: any;
+}
+export declare class Procedure {
+    /**
+     * Executes a DDL/DML statement to create or modify a stored procedure without results.
+     * * @param {string} sql The SQL statement (e.g., CREATE PROCEDURE).
+     * @param {string} [datasourceName] Optional name of the data source to use.
+     */
+    static create(sql: string, datasourceName?: string): void;
+    /**
+     * Executes a stored procedure call and returns the result set(s).
+     * * @param {string} sql The callable statement (e.g., {CALL my_procedure(?, ?)}).
+     * @param {(string | number | ProcedureParameter)[]} [parameters=[]] An array of parameters. Primitives (string/number) are automatically typed. Use ProcedureParameter for explicit types.
+     * @param {string} [datasourceName] Optional name of the data source to use.
+     * @returns {any[]} An array of JSON objects representing the result set(s).
+     */
+    static execute(sql: string, parameters?: (string | number | ProcedureParameter)[], datasourceName?: string): any[];
+}

package/dist/dts/db/query.d.ts

@@ -0,0 +1,48 @@
+/**
+ * API Query
+ *
+ */
+/**
+ * Interface used to wrap complex or specific values for non-named queries.
+ */
+export interface QueryParameter {
+    readonly value: any;
+}
+/**
+ * Interface defining a parameter for a named query (using placeholders like :paramName).
+ */
+export interface NamedQueryParameter {
+    readonly name: string;
+    readonly type: string;
+    readonly value: any;
+}
+/**
+ * Interface to specify formatting options for the query result set.
+ */
+export interface ResultParameter {
+    readonly dateFormat: string;
+}
+/**
+ * Provides static methods for executing parameterized SQL SELECT statements.
+ */
+export declare class Query {
+    /**
+     * Executes a standard SQL query with positional parameters ('?').
+     *
+     * @param sql The SQL query to execute.
+     * @param parameters An optional array of values (primitives or QueryParameter objects) to replace '?' placeholders.
+     * @param datasourceName The name of the database connection to use (optional).
+     * @param resultParameter Optional formatting parameters for the result set (e.g., date format).
+     * @returns An array of records representing the query results.
+     */
+    static execute(sql: string, parameters?: (string | number | boolean | Date | QueryParameter)[], datasourceName?: string, resultParameter?: ResultParameter): any[];
+    /**
+     * Executes a SQL query with named parameters (e.g., ":name", ":id").
+     *
+     * @param sql The SQL query to execute.
+     * @param parameters An optional array of NamedQueryParameter objects.
+     * @param datasourceName The name of the database connection to use (optional).
+     * @returns An array of records representing the query results.
+     */
+    static executeNamed(sql: string, parameters?: NamedQueryParameter[], datasourceName?: string): any[];
+}

package/dist/dts/db/repository.d.ts

@@ -0,0 +1,64 @@
+import { EntityConstructor, Options } from "@aerokit/sdk/db";
+/**
+ * Represents the data structure passed to the event trigger method before/after an operation.
+ */
+export interface EntityEvent<T> {
+    readonly operation: 'create' | 'update' | 'delete';
+    readonly table: string;
+    readonly entity: Partial<T>;
+    readonly key: {
+        name: string;
+        column: string;
+        value: string | number;
+    };
+    readonly previousEntity?: T;
+}
+/**
+ * Abstract base class for data access/business logic, wrapping the `store` API.
+ * It handles entity metadata lookup, CRUD operations, translation, and event triggering.
+ * @template T The entity type (must be an object).
+ */
+export declare abstract class Repository<T extends Record<string, any>> {
+    private entityConstructor;
+    constructor(entityConstructor: EntityConstructor);
+    protected getEntityName(): string;
+    protected getTableName(): string;
+    protected getIdName(): string;
+    protected getIdColumn(): string;
+    /**
+     * Finds all entities matching the given options.
+     */
+    findAll(options?: Options): T[];
+    /**
+     * Finds a single entity by its primary key ID.
+     */
+    findById(id: number | string, options?: Options): T | undefined;
+    /**
+     * Creates a new entity in the database.
+     * @returns The generated ID (string or number).
+     */
+    create(entity: T): string | number;
+    /**
+     * Updates an existing entity.
+     * The entity must contain the primary key.
+     */
+    update(entity: T): void;
+    /**
+     * Creates the entity if the ID is null/undefined, otherwise updates it.
+     * If an ID is provided but the entity doesn't exist, it creates it.
+     * @returns The entity's ID.
+     */
+    upsert(entity: T): string | number;
+    /**
+     * Deletes an entity by its primary key ID.
+     */
+    deleteById(id: number | string): void;
+    /**
+     * Counts the number of entities matching the given options.
+     */
+    count(options?: Options): number;
+    /**
+     * Protected method intended for subclass overriding or internal event handling.
+     */
+    protected triggerEvent(_data: EntityEvent<T>): Promise<void>;
+}

package/dist/dts/db/sequence.d.ts

@@ -0,0 +1,34 @@
+/**
+ * API Sequence
+ *
+ * Provides static methods for managing and accessing database sequences.
+ */
+/**
+ * Utility class for interacting with database sequence objects.
+ */
+export declare class Sequence {
+    /**
+     * Retrieves the next available value from a specified sequence.
+     *
+     * @param sequence The name of the database sequence.
+     * @param tableName Optional: The name of the table associated with the sequence (depends on database dialect/facade implementation).
+     * @param datasourceName Optional: The name of the database connection to use.
+     * @returns The next sequence value as a number.
+     */
+    static nextval(sequence: string, tableName?: string, datasourceName?: string): number;
+    /**
+     * Creates a new database sequence.
+     *
+     * @param sequence The name of the sequence to create.
+     * @param start Optional: The starting value for the sequence (defaults to 1 if not provided).
+     * @param datasourceName Optional: The name of the database connection to use.
+     */
+    static create(sequence: string, start?: number, datasourceName?: string): void;
+    /**
+     * Drops (deletes) an existing database sequence.
+     *
+     * @param sequence The name of the sequence to drop.
+     * @param datasourceName Optional: The name of the database connection to use.
+     */
+    static drop(sequence: string, datasourceName?: string): void;
+}

package/dist/dts/db/sql.d.ts

@@ -0,0 +1,267 @@
+import { Connection } from "./database";
+/**
+ * Union type representing all supported SQL data types.
+ */
+export type DataType = "VARCHAR" | "TEXT" | "CHAR" | "DATE" | "SECONDDATE" | "TIME" | "DATETIME" | "TIMESTAMP" | "INTEGER" | "INT" | "TINYINT" | "BIGINT" | "SMALLINT" | "REAL" | "DOUBLE" | "DOUBLE PRECISIO" | "BOOLEAN" | "BLOB" | "DECIMAL" | "BIT" | "NVARCHAR" | "FLOAT" | "BYTE" | "NCLOB" | "ARRAY" | "VARBINARY" | "BINARY VARYIN" | "SHORTTEXT" | "ALPHANUM" | "CLOB" | "SMALLDECIMAL" | "BINARY" | "ST_POINT" | "ST_GEOMETRY" | "CHARACTER VARYIN" | "BINARY LARG OBJECT" | "CHARACTER LARG OBJECT" | "CHARACTER" | "NCHAR" | "NUMERIC";
+/**
+ * Abstract base class for all SQL builders. Handles connection, native facade,
+ * and parameter collection.
+ */
+declare abstract class AbstractSQLBuilder {
+    readonly params: any[];
+    protected readonly connection?: Connection;
+    protected native: any;
+    constructor(connection?: Connection);
+    /**
+     * Hook for subclasses to set up the native builder object (e.g., calling .select()).
+     */
+    protected prepareBuilder(builder: any): any;
+    parameters(): any[];
+    /**
+     * Adds parameter(s) to the internal list. Handles single values and arrays of values.
+     */
+    protected addParameter(value: any | any[]): void;
+    /**
+     * Builds and returns the final SQL string.
+     */
+    build(): string;
+}
+/**
+ * Main entry point for the SQL Builder. Acts as a factory for specific builders.
+ */
+export declare class SQLBuilder extends AbstractSQLBuilder {
+    /**
+     * Factory method to get a dialect-specific SQLBuilder instance.
+     */
+    static getDialect(connection?: Connection): SQLBuilder;
+    select(): SelectBuilder;
+    insert(): InsertBuilder;
+    update(): UpdateBuilder;
+    delete(): DeleteBuilder;
+    nextval(name: string): NextvalBuilder;
+    create(): CreateBuilder;
+    drop(): DropBuilder;
+}
+/**
+ * Builder for SELECT statements.
+ */
+export declare class SelectBuilder extends AbstractSQLBuilder {
+    protected prepareBuilder(builder: any): any;
+    distinct(): SelectBuilder;
+    forUpdate(): SelectBuilder;
+    column(column: string): SelectBuilder;
+    from(table: string, alias?: string): SelectBuilder;
+    join(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    innerJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    outerJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    leftJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    rightJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    fullJoin(table: string, on: string, alias?: string, parameters?: any | any[]): SelectBuilder;
+    /**
+     * Sets the WHERE condition.
+     * @param condition The SQL condition string (e.g., "column1 = ?").
+     * @param parameters Optional parameters to replace '?' in the condition.
+     */
+    where(condition: string, parameters?: any | any[]): SelectBuilder;
+    order(column: string, asc?: boolean): SelectBuilder;
+    group(column: string): SelectBuilder;
+    limit(limit: number): SelectBuilder;
+    offset(offset: number): SelectBuilder;
+    having(having: string): SelectBuilder;
+    union(select: string): SelectBuilder;
+}
+/**
+ * Builder for INSERT statements.
+ */
+export declare class InsertBuilder extends AbstractSQLBuilder {
+    protected prepareBuilder(builder: any): any;
+    into(table: string): InsertBuilder;
+    column(column: string): InsertBuilder;
+    /**
+     * Sets the value for the last column specified.
+     * @param value The value placeholder (e.g., "?") or literal.
+     * @param parameters Optional parameters if a placeholder was used.
+     */
+    value(value: string, parameters?: any | any[]): InsertBuilder;
+    select(select: string): InsertBuilder;
+}
+/**
+ * Builder for UPDATE statements.
+ */
+export declare class UpdateBuilder extends AbstractSQLBuilder {
+    protected prepareBuilder(builder: any): any;
+    table(table: string): UpdateBuilder;
+    /**
+     * Sets a column to a value.
+     * @param column The column name.
+     * @param value The value placeholder (e.g., "?") or literal.
+     * @param parameters Optional parameters if a placeholder was used.
+     */
+    set(column: string, value: string, parameters?: any | any[]): UpdateBuilder;
+    /**
+     * Sets the WHERE condition for the update.
+     * @param condition The SQL condition string (e.g., "column1 = ?").
+     * @param parameters Optional parameters to replace '?' in the condition.
+     */
+    where(condition: string, parameters?: any | any[]): UpdateBuilder;
+}
+/**
+ * Builder for DELETE statements.
+ */
+export declare class DeleteBuilder extends AbstractSQLBuilder {
+    protected prepareBuilder(builder: any): any;
+    from(table: string): DeleteBuilder;
+    /**
+     * Sets the WHERE condition for the deletion.
+     * @param condition The SQL condition string (e.g., "column1 = ?").
+     * @param parameters Optional parameters to replace '?' in the condition.
+     */
+    where(condition: string, parameters?: any | any[]): DeleteBuilder;
+}
+/**
+ * Builder for selecting the next value from a sequence.
+ */
+export declare class NextvalBuilder extends AbstractSQLBuilder {
+    private name;
+    constructor(name: string, connection?: Connection);
+    protected prepareBuilder(builder: any): any;
+}
+/**
+ * Builder for CREATE statements (Table, View, Sequence).
+ */
+export declare class CreateBuilder extends AbstractSQLBuilder {
+    table(table: string): CreateTableBuilder;
+    view(view: string): CreateViewBuilder;
+    sequence(sequence: string): CreateSequenceBuilder;
+}
+/**
+ * Builder for CREATE TABLE statements.
+ */
+export declare class CreateTableBuilder extends AbstractSQLBuilder {
+    constructor(table: string, connection?: Connection);
+    /**
+     * Adds a generic column definition.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    column(name: string, type: DataType, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, isFuzzyIndexEnabled?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a VARCHAR column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnVarchar(name: string, length: number, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds an NVARCHAR column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnNvarchar(name: string, length: number, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a CHAR column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnChar(name: string, length: number, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a DATE column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnDate(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a TIME column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnTime(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a TIMESTAMP column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnTimestamp(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds an INTEGER column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnInteger(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a TINYINT column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnTinyint(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a BIGINT column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnBigint(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a SMALLINT column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnSmallint(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a REAL column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnReal(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a DOUBLE column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnDouble(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a BOOLEAN column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnBoolean(name: string, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a BLOB column.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnBlob(name: string, isNullable?: boolean, ...args: string[]): CreateTableBuilder;
+    /**
+     * Adds a DECIMAL column with precision and scale.
+     * @param args Additional dialect-specific arguments passed as an array to native.
+     */
+    columnDecimal(name: string, precision: number, scale: number, isPrimaryKey?: boolean, isNullable?: boolean, isUnique?: boolean, isIdentity?: boolean, ...args: string[]): CreateTableBuilder;
+    primaryKey(columns: string[], name?: string): CreateTableBuilder;
+    foreignKey(name: string, columns: string[], referencedTable: string, referencedColumns: string[], referencedTableSchema?: string): CreateTableBuilder;
+    unique(name: string, columns: string[]): CreateTableBuilder;
+    check(name: string, expression: string): CreateTableBuilder;
+}
+/**
+ * Builder for CREATE VIEW statements.
+ */
+export declare class CreateViewBuilder extends AbstractSQLBuilder {
+    constructor(view: string, connection?: Connection);
+    column(column: string): CreateViewBuilder;
+    asSelect(select: string): CreateViewBuilder;
+}
+/**
+ * Builder for CREATE SEQUENCE statements.
+ */
+export declare class CreateSequenceBuilder extends AbstractSQLBuilder {
+    constructor(sequence: string, connection?: Connection);
+}
+/**
+ * Builder for DROP statements (Table, View, Sequence).
+ */
+export declare class DropBuilder extends AbstractSQLBuilder {
+    table(table: string): DropTableBuilder;
+    view(view: string): DropViewBuilder;
+    sequence(sequence: string): DropSequenceBuilder;
+}
+/**
+ * Builder for DROP TABLE statements.
+ */
+export declare class DropTableBuilder extends AbstractSQLBuilder {
+    constructor(table: string, connection?: Connection);
+}
+/**
+ * Builder for DROP VIEW statements.
+ */
+export declare class DropViewBuilder extends AbstractSQLBuilder {
+    constructor(view: string, connection?: Connection);
+}
+/**
+ * Builder for DROP SEQUENCE statements.
+ */
+export declare class DropSequenceBuilder extends AbstractSQLBuilder {
+    constructor(sequence: string, connection?: Connection);
+}
+export {};

package/dist/dts/db/store.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Defines the available comparison operators for query conditions.
+ */
+export declare enum Operator {
+    EQ = "=",// Equals
+    NE = "<>",// Not Equals
+    GT = ">",// Greater Than
+    LT = "<",// Less Than
+    GE = ">=",// Greater Than or Equals
+    LE = "<=",// Less Than or Equals
+    LIKE = "LIKE",// SQL LIKE operator
+    BETWEEN = "BETWEEN",// SQL BETWEEN operator (requires two values)
+    IN = "IN"
+}
+/**
+ * Defines the direction for sorting.
+ */
+export declare enum Direction {
+    ASC = "ASC",// Ascending
+    DESC = "DESC"
+}
+/**
+ * Represents a single condition for filtering data.
+ */
+export interface Condition {
+    propertyName: string;
+    operator: Operator;
+    value: any | any[];
+}
+/**
+ * Represents a single sorting instruction.
+ */
+export interface Sort {
+    propertyName: string;
+    direction: Direction;
+}
+/**
+ * Defines optional parameters for list and count operations.
+ */
+export interface Options {
+    conditions?: Condition[];
+    sorts?: Sort[];
+    limit?: number;
+    offset?: number;
+    language?: string;
+}
+/**
+ * Facade class for interacting with the underlying Dirigible Data Store.
+ * All methods serialize/deserialize JavaScript objects to/from JSON strings
+ * before interacting with the native Java facade.
+ */
+export declare class Store {
+    /**
+     * Saves a new entry to the data store.
+     * @param name The entity/table name.
+     * @param entry The JavaScript object to save.
+     * @returns The ID of the newly created entry (string or number).
+     */
+    static save(name: string, entry: any): string | number;
+    /**
+     * Inserts a new entry or updates an existing one if the ID is present.
+     * @param name The entity/table name.
+     * @param entry The JavaScript object to insert/update.
+     */
+    static upsert(name: string, entry: any): void;
+    /**
+     * Updates an existing entry.
+     * @param name The entity/table name.
+     * @param entry The JavaScript object with the ID and updated data.
+     */
+    static update(name: string, entry: any): void;
+    /**
+     * Lists entries based on optional filtering, sorting, and pagination options.
+     * @param name The entity/table name.
+     * @param options Optional {@link Options} for query execution.
+     * @returns An array of JavaScript objects.
+     */
+    static list(name: string, options?: Options): any[];
+    /**
+     * Counts the number of entries based on optional filtering options.
+     * @param name The entity/table name.
+     * @param options Optional {@link Options} for query execution.
+     * @returns The count of matching entries.
+     */
+    static count(name: string, options?: Options): number;
+    /**
+     * Retrieves a single entry by its ID.
+     * @param name The entity/table name.
+     * @param id The ID of the entry.
+     * @returns The entry object, or undefined if not found.
+     */
+    static get(name: string, id: any): any | undefined;
+    /**
+     * Deletes an entry by its ID.
+     * @param name The entity/table name.
+     * @param id The ID of the entry to remove.
+     */
+    static remove(name: string, id: any): void;
+    /**
+     * Finds entries matching an example object (query-by-example).
+     * @param name The entity/table name.
+     * @param example An object containing properties to match.
+     * @param limit Maximum number of results to return.
+     * @param offset Number of results to skip.
+     * @returns An array of matching JavaScript objects.
+     */
+    static find(name: string, example: any, limit?: number, offset?: number): any[];
+    /**
+     * Queries all entries for a given entity name with pagination.
+     * @param name The entity/table name.
+     * @param limit Maximum number of results to return.
+     * @param offset Number of results to skip.
+     * @returns An array of JavaScript objects.
+     */
+    static query(name: string, limit?: number, offset?: number): any[];
+    /**
+     * Queries all entries for a given entity name without pagination.
+     * @param name The entity/table name.
+     * @returns An array of all JavaScript objects.
+     */
+    static queryNative(name: string): any[];
+    /**
+     * Gets the name of the entity associated with the store name.
+     */
+    static getEntityName(name: string): string;
+    /**
+     * Gets the underlying database table name for the entity.
+     */
+    static getTableName(name: string): string;
+    /**
+     * Gets the property name used as the ID field in the entity object.
+     */
+    static getIdName(name: string): string;
+    /**
+     * Gets the underlying database column name used for the ID field.
+     */
+    static getIdColumn(name: string): string;
+}