@decaf-ts/core 0.1.3 → 0.2.0

package/lib/esm/query/options.d.ts

@@ -0,0 +1,371 @@
+import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
+import { Executor } from "../interfaces";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Condition } from "./Condition";
+/**
+ * @summary Statement Builder interface
+ * @description Exposes the final method to build the statement
+ *
+ * @typedef Q The query object type to build
+ * @interface QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ *
+ */
+export interface QueryBuilder<Q> extends Executor {
+    /**
+     * Method to build and validate the prepared statement before the execution;
+     *
+     * @throws {QueryError}  for invalid statements
+     * @method
+     */
+    build(previous: Q): Q;
+}
+/**
+ * @summary GroupBy Option interface
+ * @description Exposes the GROUP BY method and remaining options
+ *
+ * @interface GroupByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface GroupByOption extends Executor {
+    /**
+     * @summary Groups records by an attribute
+     *
+     * @param {GroupBySelector} selector
+     * @method
+     */
+    groupBy(selector: GroupBySelector): Executor;
+}
+/**
+ * @summary Offset Option interface
+ * @description Exposes the OFFSET method and remaining options
+ *
+ * @interface GroupByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OffsetOption extends Executor {
+    /**
+     * @summary Offsets the results by the provided selector
+     *
+     * @param {OffsetSelector} selector
+     * @method
+     */
+    offset(selector: OffsetSelector): Executor;
+}
+/**
+ * @summary Limit Option interface
+ * @description Exposes the LIMIT method and remaining options
+ *
+ * @interface LimitOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface LimitOption extends Executor {
+    /**
+     * @summary Limits the results to the provided number
+     *
+     * @param {LimitSelector} selector
+     * @method
+     */
+    limit(selector: LimitSelector): OffsetOption;
+}
+/**
+ * @summary OrderpBy Option interface
+ * @description Exposes the ORDER BY method and remaining options
+ *
+ * @interface OrderByOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OrderByOption extends Executor {
+    /**
+     * @summary Orders the results by the provided attribute and according to the provided direction
+     *
+     * @param {OrderBySelector} selector
+     * @method
+     */
+    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
+}
+/**
+ * @summary Groups several order and grouping options
+ *
+ * @interface OrderAndGroupOption
+ * @extends OrderByOption
+ * @extends GroupByOption
+ * @extends LimitOption
+ * @extends OffsetOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface OrderAndGroupOption extends OrderByOption, GroupByOption, LimitOption, OffsetOption {
+}
+/**
+ * @summary Where Option interface
+ * @description Exposes the WHERE method and remaining options
+ *
+ * @interface WhereOption
+ * @extends OrderAndGroupOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface WhereOption extends OrderAndGroupOption {
+    /**
+     * @summary filter the records by a condition
+     *
+     * @param {Condition} condition
+     * @method
+     */
+    where(condition: Condition): OrderAndGroupOption;
+}
+/**
+ * @summary From Option Interface
+ * @description Exposes the FROM method and remaining options
+ *
+ * @interface FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface FromOption<M extends Model> {
+    /**
+     * @summary selects records from a table
+     *
+     * @param {Constructor} tableName
+     * @method
+     */
+    from(tableName: Constructor<M> | string): WhereOption;
+}
+/**
+ * @summary Distinct Option Interface
+ * @description Exposes the remaining options after a DISTINCT
+ *
+ * @interface DistinctOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface DistinctOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Max Option Interface
+ * @description Exposes the remaining options after a MAX
+ *
+ * @interface MaxOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface MaxOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Min Option Interface
+ * @description Exposes the remaining options after a MIN
+ *
+ * @interface MinOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface MinOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Count Option Interface
+ * @description Exposes the remaining options after a COUNT
+ *
+ * @interface CountOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface CountOption<M extends Model> extends FromOption<M> {
+}
+/**
+ * @summary Select Option Interface
+ * @description Exposes the remaining options after a SELECT
+ *
+ * @interface SelectOption
+ * @extends FromOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface SelectOption<M extends Model> extends FromOption<M> {
+    /**
+     * @summary selects distinct values
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    distinct(selector: SelectSelector): DistinctOption<M>;
+    /**
+     * @summary the maximum value
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    max(selector: SelectSelector): MaxOption<M>;
+    /**
+     * @summary selects the minimum value
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    min(selector: SelectSelector): MinOption<M>;
+    /**
+     * @summary counts the records
+     *
+     * @param {SelectSelector} selector
+     * @method
+     */
+    count(selector: SelectSelector): CountOption<M>;
+}
+/**
+ * @summary Into Option Interface
+ * @description Exposes the remaining options after an INTO
+ *
+ * @interface IntoOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface IntoOption<M extends Model> {
+    /**
+     * @summary sets the models to insert
+     *
+     * @param {T[]} models
+     * @method
+     */
+    values(...models: M[]): Executor;
+    /**
+     * @summary filter records to insert
+     *
+     * @param {Condition} condition
+     * @method
+     */
+    where(condition: Condition): Executor;
+}
+/**
+ * @summary Valuest Option Interface
+ * @description Exposes the remaining options after a VALUES
+ *
+ * @interface ValuesOption
+ * @extends QueryBuilder
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface ValuesOption extends Executor {
+}
+/**
+ * @summary Insert Option Interface
+ * @description Exposes the remaining options after an INSERT
+ *
+ * @interface InsertOption
+ *
+ * @category Query
+ * @subcategory Options
+ */
+export interface InsertOption<M extends Model> {
+    /**
+     * @summary selects the table to insert records into
+     *
+     * @param {string | Constructor} table
+     * @method
+     */
+    into(table: Constructor<M>): IntoOption<M>;
+}
+/**
+ * @summary {@link Operator} Option Interface
+ * @description Exposes the available operators for a {@link Condition}
+ *
+ * @interface AttributeOption
+ *
+ * @category Query
+ * @subcategory Conditions
+ */
+export interface AttributeOption {
+    /**
+     * @summary Test equality
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    eq(val: any): Condition;
+    /**
+     * @summary Test difference
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    dif(val: any): Condition;
+    /**
+     * @summary Test greater than
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    gt(val: any): Condition;
+    /**
+     * @summary Test lower than
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    lt(val: any): Condition;
+    /**
+     * @summary Test greater or equal to
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    gte(val: any): Condition;
+    /**
+     * @summary Test lower or equal to
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    lte(val: any): Condition;
+    /**
+     * @summary Test value in a range of values
+     * @param {any[]} val
+     */
+    in(val: any[]): Condition;
+    /**
+     * @summary Test matches {@link RegExp}
+     *
+     * @param {any} val the value to test
+     * @method
+     */
+    regexp(val: string | RegExp): Condition;
+}
+/**
+ * @summary The starting point for creating Conditions
+ * @description Exposes the available operations for a {@link Condition}
+ *
+ * @interface ConditionBuilderOption
+ *
+ * @category Query
+ * @subcategory Conditions
+ */
+export interface ConditionBuilderOption {
+    attribute(attr: string): AttributeOption;
+}

package/lib/esm/query/options.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/query/options.ts"],"names":[],"mappings":"","file":"query/options.js","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport {\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Executor } from \"../interfaces\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Condition } from \"./Condition\";\n\n/**\n * @summary Statement Builder interface\n * @description Exposes the final method to build the statement\n *\n * @typedef Q The query object type to build\n * @interface QueryBuilder\n *\n * @category Query\n * @subcategory Options\n *\n */\nexport interface QueryBuilder<Q> extends Executor {\n  /**\n   * Method to build and validate the prepared statement before the execution;\n   *\n   * @throws {QueryError}  for invalid statements\n   * @method\n   */\n  build(previous: Q): Q;\n}\n\n/**\n * @summary GroupBy Option interface\n * @description Exposes the GROUP BY method and remaining options\n *\n * @interface GroupByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface GroupByOption extends Executor {\n  /**\n   * @summary Groups records by an attribute\n   *\n   * @param {GroupBySelector} selector\n   * @method\n   */\n  groupBy(selector: GroupBySelector): Executor;\n}\n/**\n * @summary Offset Option interface\n * @description Exposes the OFFSET method and remaining options\n *\n * @interface GroupByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OffsetOption extends Executor {\n  /**\n   * @summary Offsets the results by the provided selector\n   *\n   * @param {OffsetSelector} selector\n   * @method\n   */\n  offset(selector: OffsetSelector): Executor;\n}\n/**\n * @summary Limit Option interface\n * @description Exposes the LIMIT method and remaining options\n *\n * @interface LimitOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface LimitOption extends Executor {\n  /**\n   * @summary Limits the results to the provided number\n   *\n   * @param {LimitSelector} selector\n   * @method\n   */\n  limit(selector: LimitSelector): OffsetOption;\n}\n/**\n * @summary OrderpBy Option interface\n * @description Exposes the ORDER BY method and remaining options\n *\n * @interface OrderByOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OrderByOption extends Executor {\n  /**\n   * @summary Orders the results by the provided attribute and according to the provided direction\n   *\n   * @param {OrderBySelector} selector\n   * @method\n   */\n  orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;\n}\n/**\n * @summary Groups several order and grouping options\n *\n * @interface OrderAndGroupOption\n * @extends OrderByOption\n * @extends GroupByOption\n * @extends LimitOption\n * @extends OffsetOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface OrderAndGroupOption\n  extends OrderByOption,\n    GroupByOption,\n    LimitOption,\n    OffsetOption {}\n/**\n * @summary Where Option interface\n * @description Exposes the WHERE method and remaining options\n *\n * @interface WhereOption\n * @extends OrderAndGroupOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface WhereOption extends OrderAndGroupOption {\n  /**\n   * @summary filter the records by a condition\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition): OrderAndGroupOption;\n}\n\n/**\n * @summary From Option Interface\n * @description Exposes the FROM method and remaining options\n *\n * @interface FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface FromOption<M extends Model> {\n  /**\n   * @summary selects records from a table\n   *\n   * @param {Constructor} tableName\n   * @method\n   */\n  from(tableName: Constructor<M> | string): WhereOption;\n}\n\n/**\n * @summary Distinct Option Interface\n * @description Exposes the remaining options after a DISTINCT\n *\n * @interface DistinctOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface DistinctOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Max Option Interface\n * @description Exposes the remaining options after a MAX\n *\n * @interface MaxOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface MaxOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Min Option Interface\n * @description Exposes the remaining options after a MIN\n *\n * @interface MinOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface MinOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Count Option Interface\n * @description Exposes the remaining options after a COUNT\n *\n * @interface CountOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface CountOption<M extends Model> extends FromOption<M> {}\n\n/**\n * @summary Select Option Interface\n * @description Exposes the remaining options after a SELECT\n *\n * @interface SelectOption\n * @extends FromOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface SelectOption<M extends Model> extends FromOption<M> {\n  /**\n   * @summary selects distinct values\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  distinct(selector: SelectSelector): DistinctOption<M>;\n  /**\n   * @summary the maximum value\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  max(selector: SelectSelector): MaxOption<M>;\n  /**\n   * @summary selects the minimum value\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  min(selector: SelectSelector): MinOption<M>;\n  /**\n   * @summary counts the records\n   *\n   * @param {SelectSelector} selector\n   * @method\n   */\n  count(selector: SelectSelector): CountOption<M>;\n}\n\n/**\n * @summary Into Option Interface\n * @description Exposes the remaining options after an INTO\n *\n * @interface IntoOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface IntoOption<M extends Model> {\n  /**\n   * @summary sets the models to insert\n   *\n   * @param {T[]} models\n   * @method\n   */\n  values(...models: M[]): Executor;\n  /**\n   * @summary filter records to insert\n   *\n   * @param {Condition} condition\n   * @method\n   */\n  where(condition: Condition): Executor;\n}\n/**\n * @summary Valuest Option Interface\n * @description Exposes the remaining options after a VALUES\n *\n * @interface ValuesOption\n * @extends QueryBuilder\n *\n * @category Query\n * @subcategory Options\n */\nexport interface ValuesOption extends Executor {}\n/**\n * @summary Insert Option Interface\n * @description Exposes the remaining options after an INSERT\n *\n * @interface InsertOption\n *\n * @category Query\n * @subcategory Options\n */\nexport interface InsertOption<M extends Model> {\n  /**\n   * @summary selects the table to insert records into\n   *\n   * @param {string | Constructor} table\n   * @method\n   */\n  into(table: Constructor<M>): IntoOption<M>;\n}\n\n/**\n * @summary {@link Operator} Option Interface\n * @description Exposes the available operators for a {@link Condition}\n *\n * @interface AttributeOption\n *\n * @category Query\n * @subcategory Conditions\n */\nexport interface AttributeOption {\n  /**\n   * @summary Test equality\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  eq(val: any): Condition;\n  /**\n   * @summary Test difference\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  dif(val: any): Condition;\n  /**\n   * @summary Test greater than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gt(val: any): Condition;\n  /**\n   * @summary Test lower than\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lt(val: any): Condition;\n  /**\n   * @summary Test greater or equal to\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  gte(val: any): Condition;\n  /**\n   * @summary Test lower or equal to\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  lte(val: any): Condition;\n  /**\n   * @summary Test value in a range of values\n   * @param {any[]} val\n   */\n  in(val: any[]): Condition;\n  /**\n   * @summary Test matches {@link RegExp}\n   *\n   * @param {any} val the value to test\n   * @method\n   */\n  regexp(val: string | RegExp): Condition;\n}\n/**\n * @summary The starting point for creating Conditions\n * @description Exposes the available operations for a {@link Condition}\n *\n * @interface ConditionBuilderOption\n *\n * @category Query\n * @subcategory Conditions\n */\nexport interface ConditionBuilderOption {\n  attribute(attr: string): AttributeOption;\n}\n"]}

package/lib/esm/query/selectors.d.ts

@@ -0,0 +1,38 @@
+import { OrderDirection } from "../repository";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+/**
+ * @typedef FromSelector
+ *
+ * @category Clauses
+ */
+export type FromSelector<M extends Model> = Constructor<M> | string;
+/**
+ * @typedef GroupBySelector
+ *
+ * @category Clauses
+ */
+export type GroupBySelector = string;
+/**
+ * @typedef OrderBySelector
+ *
+ * @category Clauses
+ */
+export type OrderBySelector = [string, OrderDirection];
+/**
+ * @typedef LimitSelector
+ *
+ * @category Clauses
+ */
+export type LimitSelector = number;
+/**
+ * @typedef OffsetSelector
+ *
+ * @category Clauses
+ */
+export type OffsetSelector = number;
+/**
+ * @typedef SelectSelector
+ *
+ * @category Clauses
+ */
+export type SelectSelector = string | string[];

package/lib/esm/query/selectors.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS9zZWxlY3RvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJxdWVyeS9zZWxlY3RvcnMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPcmRlckRpcmVjdGlvbiB9IGZyb20gXCIuLi9yZXBvc2l0b3J5XCI7XG5pbXBvcnQgeyBDb25zdHJ1Y3RvciwgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbi8qKlxuICogQHR5cGVkZWYgRnJvbVNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgRnJvbVNlbGVjdG9yPE0gZXh0ZW5kcyBNb2RlbD4gPSBDb25zdHJ1Y3RvcjxNPiB8IHN0cmluZztcbi8qKlxuICogQHR5cGVkZWYgR3JvdXBCeVNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgR3JvdXBCeVNlbGVjdG9yID0gc3RyaW5nO1xuLyoqXG4gKiBAdHlwZWRlZiBPcmRlckJ5U2VsZWN0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgQ2xhdXNlc1xuICovXG5leHBvcnQgdHlwZSBPcmRlckJ5U2VsZWN0b3IgPSBbc3RyaW5nLCBPcmRlckRpcmVjdGlvbl07XG4vKipcbiAqIEB0eXBlZGVmIExpbWl0U2VsZWN0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgQ2xhdXNlc1xuICovXG5leHBvcnQgdHlwZSBMaW1pdFNlbGVjdG9yID0gbnVtYmVyO1xuLyoqXG4gKiBAdHlwZWRlZiBPZmZzZXRTZWxlY3RvclxuICpcbiAqIEBjYXRlZ29yeSBDbGF1c2VzXG4gKi9cbmV4cG9ydCB0eXBlIE9mZnNldFNlbGVjdG9yID0gbnVtYmVyO1xuXG4vLyBleHBvcnQgdHlwZSBTZWxlY3RGdW5jdGlvbjxUID0gYW55PiA9IChvYmo6IFQpID0+IFQgfCBhbnk7XG4vKipcbiAqIEB0eXBlZGVmIFNlbGVjdFNlbGVjdG9yXG4gKlxuICogQGNhdGVnb3J5IENsYXVzZXNcbiAqL1xuZXhwb3J0IHR5cGUgU2VsZWN0U2VsZWN0b3IgPSBzdHJpbmcgfCBzdHJpbmdbXTtcbiJdfQ==

package/lib/esm/query/types.d.ts

@@ -0,0 +1,2 @@
+export type AttributeResult = Record<string, string>;
+export type OperationResult = Record<string, AttributeResult | any>;

package/lib/esm/query/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9xdWVyeS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6InF1ZXJ5L3R5cGVzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgQXR0cmlidXRlUmVzdWx0ID0gUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblxuZXhwb3J0IHR5cGUgT3BlcmF0aW9uUmVzdWx0ID0gUmVjb3JkPHN0cmluZywgQXR0cmlidXRlUmVzdWx0IHwgYW55PjtcbiJdfQ==

package/lib/esm/repository/Repository.d.ts

@@ -1,22 +1,32 @@
-import { DBModel, Repository as Rep } from "@decaf-ts/db-decorators";
+import { Repository as Rep } from "@decaf-ts/db-decorators";
 import { Observable } from "../interfaces/Observable";
 import { Observer } from "../interfaces/Observer";
 import { Adapter } from "../persistence/Adapter";
-import { Constructor } from "@decaf-ts/decorator-validation";
-export declare class Repository<T extends DBModel, V = any> extends Rep<T> implements Observable {
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Condition, SelectSelector, WhereOption } from "../query";
+import { OrderDirection } from "./constants";
+import { SequenceOptions } from "../interfaces";
+import { Queriable } from "../interfaces/Queriable";
+export declare class Repository<M extends Model, Q = any> extends Rep<M> implements Observable, Queriable {
+    private static _cache;
     private observers;
     private readonly _adapter;
     private _tableName;
     private _pk;
-    get adapter(): Adapter<any, V>;
+    get adapter(): Adapter<any, Q>;
     protected get tableName(): string;
     protected get pk(): string;
-    constructor(adapter?: Adapter<any, V>, clazz?: Constructor<T>);
-    create(model: T, ...args: any[]): Promise<T>;
-    read(id: string, ...args: any[]): Promise<T>;
-    update(model: T, ...args: any[]): Promise<T>;
-    protected updatePrefix(model: T, ...args: any[]): Promise<[T, ...args: any[]]>;
-    delete(id: string, ...args: any[]): Promise<T>;
+    constructor(adapter?: Adapter<any, Q>, clazz?: Constructor<M>);
+    create(model: M, ...args: any[]): Promise<M>;
+    createAll(models: M[], ...args: any[]): Promise<M[]>;
+    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    read(id: string | number | bigint, ...args: any[]): Promise<M>;
+    update(model: M, ...args: any[]): Promise<M>;
+    protected updatePrefix(model: M, ...args: any[]): Promise<[M, ...args: any[]]>;
+    protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    delete(id: string | number | bigint, ...args: any[]): Promise<M>;
+    select(selector?: SelectSelector): WhereOption;
+    query<V>(condition: Condition, orderBy: string, order?: OrderDirection, limit?: number, skip?: number): Promise<V>;
     /**
      * @summary Registers an {@link Observer}
      * @param {Observer} observer
@@ -36,5 +46,11 @@ export declare class Repository<T extends DBModel, V = any> extends Rep<T> imple
      * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
      */
     updateObservers(...args: any[]): Promise<void>;
-    static forModel<T extends DBModel>(model: Constructor<T>): Repository<T>;
+    static forModel<M extends Model, R extends Repository<M, any>>(model: Constructor<M>): R;
+    private static get;
+    static register<M extends Model>(name: string, repo: Constructor<Repository<M, any>>): void;
+    static setMetadata<M extends Model>(model: M, metadata: any): void;
+    static getMetadata<M extends Model>(model: M): any;
+    static removeMetadata<M extends Model>(model: M): void;
+    static getSequenceOptions<M extends Model>(model: M): SequenceOptions;
 }