@decaf-ts/core 0.3.31 → 0.3.33

package/dist/lib/identity/decorators.d.ts

@@ -0,0 +1,24 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { SequenceOptions } from "../interfaces/SequenceOptions";
+import { Repo } from "../repository/Repository";
+import { Context } from "@decaf-ts/db-decorators/lib/repository/Context";
+/**
+ * @summary Primary Key Decorator
+ * @description Marks the property as the {@link Model}s primary key.
+ *  Also marks the property as {@link unique} as {@required} and ensures the index is created properly according to the provided {@link Sequence}
+ *
+ *
+ *
+ * @function pk
+ *
+ * @memberOf module:wallet-db.Decorators
+ *
+ * @see unique
+ * @see required
+ * @see on
+ * @param data
+ * @param key
+ * @param model
+ */
+export declare function pkOnCreate<M extends Model, V extends Repo<M>>(this: V, context: Context<M>, data: SequenceOptions, key: string, model: M): Promise<void>;
+export declare function pk(opts?: Omit<SequenceOptions, "cycle" | "startWith" | "incrementBy">): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/dist/lib/identity/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./decorators";
+export * from "./utils";

package/dist/lib/identity/utils.d.ts

@@ -0,0 +1,3 @@
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+export declare function getTableName<M extends Model>(model: M | Constructor<M>): any;
+export declare function sequenceNameForModel<M extends Model>(model: M | Constructor<M>, ...args: string[]): string;

package/dist/lib/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module ts-workspace
+ */
+/**
+ * @summary Namespace summary
+ * @description Namespace description
+ * @namespace Namespace
+ * @memberOf module:ts-workspace
+ */
+export * from "./identity";
+export * from "./interfaces";
+export * from "./model";
+export * from "./persistence";
+export * from "./query";
+export * from "./repository";
+export * from "./validators";
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+export declare const VERSION = "##VERSION##";

package/dist/lib/interfaces/Builder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @summary Standard Builder APi for the Builder design pattern
+ * @description Expose the build method
+ *
+ * @interface Builder
+ *
+ * @category Construction
+ */
+export interface Builder<T> {
+    /**
+     * @summary Build the Object
+     *
+     * @method
+     */
+    build(...args: any[]): T;
+}

package/dist/lib/interfaces/Executor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @summary processes query objects
+ *
+ * @typedef V the output
+ *
+ * @interface Executor
+ *
+ * @category Query
+ */
+export interface Executor {
+    /**
+     * @summary Processes itself
+     *
+     * @param {any[]} args
+     *
+     * @method
+     */
+    execute<V>(...args: any): Promise<V>;
+}

package/dist/lib/interfaces/Observable.d.ts

@@ -0,0 +1,31 @@
+import { Observer } from "./Observer";
+/**
+ * @summary Observable Api
+ * @description manage and update {@link Observer}s
+ *
+ * @interface Observable
+ *
+ * @category Observables
+ */
+export interface Observable {
+    /**
+     * @summary Register new {@link Observer}s
+     * @param {Observer} observer
+     *
+     * @method
+     */
+    observe(observer: Observer): void;
+    /**
+     * @summary Unregister new {@link Observer}s
+     * @param {Observer} observer
+     *
+     * @method
+     */
+    unObserve(observer: Observer): void;
+    /**
+     * @summary have registered {@link Observer}s update themselves
+     * @param {any[]} args
+     * @method
+     */
+    updateObservers(...args: any[]): Promise<void>;
+}

package/dist/lib/interfaces/Observer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @summary Observer Api
+ * @description will be called by the {@link Observable}
+ *
+ * @interface Observer
+ *
+ * @category Observables
+ */
+export interface Observer {
+    /**
+     * @summary Refreshes the Observer
+     * @param {any[]} args
+     * @method
+     */
+    refresh(...args: any[]): Promise<void>;
+}

package/dist/lib/interfaces/Paginatable.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "../query/Paginator";
+export interface Paginatable {
+    paginate<V>(...args: any[]): Promise<Paginator<V, any>>;
+}

package/dist/lib/interfaces/Queriable.d.ts

@@ -0,0 +1,6 @@
+import { Condition, SelectSelector, WhereOption } from "../query";
+import { OrderDirection } from "../repository";
+export interface Queriable {
+    select(selector?: SelectSelector): WhereOption;
+    query<V>(condition: Condition, orderBy: string, order: OrderDirection, limit?: number, skip?: number): Promise<V>;
+}

package/dist/lib/interfaces/RawExecutor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @summary Executes a raw instruction in the Database
+ * @typeDef Q The input type
+ * @typeDef R The result type
+ *
+ * @interface RawExecutor
+ * @category Query
+ */
+export interface RawExecutor<Q> {
+    /**
+     * @summary Executes a raw instruction in the Database
+     *
+     * @typeDef V the expected outcome of the instruction
+     * @param rawInput
+     * @param args
+     *
+     * @method
+     */
+    raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
+}

package/dist/lib/interfaces/SequenceOptions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @typedef SequenceOptions
+ *
+ * @prop {string | number} [startingValue] defines the starting value when sequence doest not exist
+ *
+ * @category Sequences
+ */
+export interface SequenceOptions {
+    name?: string;
+    type: "Number" | "BigInt" | undefined;
+    startWith: number;
+    incrementBy: number;
+    minValue?: number;
+    maxValue?: number;
+    cycle: boolean;
+}
+export declare const DefaultSequenceOptions: SequenceOptions;
+export declare const NumericSequence: SequenceOptions;
+export declare const BigIntSequence: SequenceOptions;

package/dist/lib/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Builder";
+export * from "./Executor";
+export * from "./Observable";
+export * from "./Observer";
+export * from "./Queriable";
+export * from "./RawExecutor";
+export * from "./SequenceOptions";

package/dist/lib/model/BaseModel.d.ts

@@ -0,0 +1,6 @@
+import { ModelArg, Model } from "@decaf-ts/decorator-validation";
+export declare abstract class BaseModel extends Model {
+    createdOn: Date;
+    updatedOn: Date;
+    protected constructor(arg?: ModelArg<BaseModel>);
+}

package/dist/lib/model/IdentifiedBaseModel.d.ts

@@ -0,0 +1,7 @@
+import { ModelArg } from "@decaf-ts/decorator-validation";
+import { BaseModel } from "./BaseModel";
+export declare abstract class IdentifiedBaseModel extends BaseModel {
+    createdBy: string;
+    updatedBy: string;
+    protected constructor(arg?: ModelArg<IdentifiedBaseModel>);
+}

package/dist/lib/model/User.d.ts

@@ -0,0 +1,8 @@
+import { Model, ModelArg } from "@decaf-ts/decorator-validation";
+import { Roles } from "../persistence/constants";
+export declare class User extends Model {
+    id: string;
+    roles?: (string | Roles)[];
+    affiliations?: string[];
+    constructor(arg?: ModelArg<User>);
+}

package/dist/lib/model/construction.d.ts

@@ -0,0 +1,15 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Repo } from "../repository/Repository";
+import { RelationsMetadata } from "./types";
+import { Context } from "@decaf-ts/db-decorators/lib/repository/Context";
+export declare function createOrUpdate<M extends Model>(model: M, context: Context<M>, repository?: Repo<M>): Promise<M>;
+export declare function oneToOneOnCreate<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function oneToOneOnUpdate<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function oneToOneOnDelete<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function oneToManyOnCreate<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function oneToManyOnUpdate<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function oneToManyOnDelete<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function getPopulateKey(tableName: string, fieldName: string, id: string | number): string;
+export declare function cacheModelForPopulate<M extends Model>(context: Context<M>, parentModel: M, propertyKey: string, pkValue: string | number, cacheValue: any): Promise<void>;
+export declare function populate<M extends Model, R extends Repo<M>, Y extends RelationsMetadata>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function repositoryFromTypeMetadata<M extends Model>(model: any, propertyKey: string): Repo<M>;

package/dist/lib/model/decorators.d.ts

@@ -0,0 +1,75 @@
+import { CascadeMetadata } from "../repository/types";
+import { OrderDirection } from "../repository/constants";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Repo } from "../repository/Repository";
+import { Context } from "../repository/Context";
+export declare function table(tableName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function column(columnName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @summary Index Decorator
+ * @description properties decorated will the index in the
+ * DB for performance in queries
+ *
+ * @param {OrderDirection[]} [directions]
+ * @param {string[]} [compositions]
+ *
+ * @function index
+ */
+export declare function index(directions?: OrderDirection[], compositions?: string[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M>, Y = any>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+/**
+ * @summary Unique Decorator
+ * @description Tags a property as unique.
+ *  No other elements in that table can have the same property value
+ *
+ * @function unique
+ *
+ * @memberOf module:wallet-db.Decorators
+ */
+export declare function unique(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M>, Y = any>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
+export declare function createdBy(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function updatedBy(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @summary One To One relation Decorators
+ *
+ * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+ * @param {CascadeMetadata} [cascadeOptions]
+ * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
+ *
+ * @function onToOne
+ *
+ * @memberOf module:wallet-db.Decorators
+ *
+ * @see oneToMany
+ * @see manyToOne
+ */
+export declare function oneToOne<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @summary One To Many relation Decorators
+ *
+ * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+ * @param {CascadeMetadata} [cascadeOptions]
+ *
+ * @function oneToMany
+ *
+ * @memberOf module:wallet-db.Decorators
+ *
+ * @see oneToOne
+ * @see manyToOne
+ */
+export declare function oneToMany<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @summary Many To One relation Decorators
+ *
+ * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+ * @param {CascadeMetadata} [cascadeOptions]
+ *
+ * @function manyToOne
+ *
+ * @memberOf module:wallet-db.Decorators
+ *
+ * @see oneToMany
+ * @see oneToOne
+ */
+export declare function manyToOne(clazz: Constructor<any>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/dist/lib/model/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BaseModel";
+export * from "./decorators";
+export * from "./types";
+export * from "./User";

package/dist/lib/model/types.d.ts

@@ -0,0 +1,6 @@
+import { CascadeMetadata } from "../repository";
+export type RelationsMetadata = {
+    class: string;
+    cascade: CascadeMetadata;
+    populate: boolean;
+};

package/dist/lib/persistence/Adapter.d.ts

@@ -0,0 +1,86 @@
+import { BaseError, Context, OperationKeys } from "@decaf-ts/db-decorators";
+import { Observer } from "../interfaces/Observer";
+import { Constructor, Model, ModelConstructor } from "@decaf-ts/decorator-validation";
+import { SequenceOptions } from "../interfaces/SequenceOptions";
+import { RawExecutor } from "../interfaces/RawExecutor";
+import { Observable } from "../interfaces/Observable";
+import { Query } from "../query/Query";
+import { Statement } from "../query/Statement";
+import { ClauseFactory } from "../query/ClauseFactory";
+import { Condition } from "../query/Condition";
+import { Repository } from "../repository/Repository";
+import { Sequence } from "./Sequence";
+import { User } from "../model/User";
+/**
+ * @summary Abstract Decaf-ts Persistence Adapter Class
+ * @description Offers the base implementation for all Adapter Classes
+ * and manages them various registered {@link Adapter}s
+ *
+ * @typedef Y the underlying persistence object type
+ * @typedef Q The query object the adapter uses
+ *
+ * @param {Y} native the underlying persistence object
+ * @param {string} flavour the under witch the persistence adapter should be stored
+ *
+ * @class Adapter
+ * @implements RawExecutor
+ * @implements Observable
+ */
+export declare abstract class Adapter<Y, Q> implements RawExecutor<Q>, Observable {
+    readonly flavour: string;
+    private static _current;
+    private static _cache;
+    protected readonly _observers: Observer[];
+    private readonly _native;
+    get native(): Y;
+    repository<M extends Model>(): Constructor<Repository<M, Q, Adapter<Y, Q>>>;
+    protected constructor(native: Y, flavour: string);
+    Query<M extends Model>(): Query<Q, M>;
+    abstract parseCondition(condition: Condition): Q;
+    abstract get Statement(): Statement<Q>;
+    abstract get Clauses(): ClauseFactory<Y, Q>;
+    protected isReserved(attr: string): boolean;
+    protected abstract parseError(err: Error): BaseError;
+    abstract initialize(...args: any[]): Promise<void>;
+    abstract Sequence(options: SequenceOptions): Promise<Sequence>;
+    protected abstract user(): Promise<User | undefined>;
+    context<M extends Model, C extends Context<M>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>): Promise<C>;
+    prepare<M extends Model>(model: M, pk: string | number): {
+        record: Record<string, any>;
+        id: string;
+    };
+    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: string, id: string | number | bigint): M;
+    abstract create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    abstract read(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    readAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    abstract update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    updateAll(tableName: string, id: string[] | number[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    abstract delete(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    deleteAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    abstract raw<R>(rawInput: Q, process: boolean, ...args: any[]): Promise<R>;
+    /**
+     * @summary Registers an {@link Observer}
+     * @param {Observer} observer
+     *
+     * @see {Observable#observe}
+     */
+    observe(observer: Observer): void;
+    /**
+     * @summary Unregisters an {@link Observer}
+     * @param {Observer} observer
+     *
+     * @see {Observable#unObserve}
+     */
+    unObserve(observer: Observer): void;
+    /**
+     * @summary calls all registered {@link Observer}s to update themselves
+     * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
+     */
+    updateObservers(...args: any[]): Promise<void>;
+    static get current(): Adapter<any, any>;
+    static get<Y, Q>(flavour: any): Adapter<Y, Q> | undefined;
+    static setCurrent(flavour: string): void;
+    static key(key: string): string;
+    static models<M extends Model>(flavour: string): ModelConstructor<any>[];
+}

package/dist/lib/persistence/Sequence.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @summary Sequence
+ *
+ * @interface Sequence
+ *
+ * @category Sequences
+ */
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { SequenceOptions } from "../interfaces/SequenceOptions";
+export declare abstract class Sequence {
+    protected readonly options: SequenceOptions;
+    protected constructor(options: SequenceOptions);
+    /**
+     * @summary generates the next value in the sequence
+     *
+     * @method
+     */
+    abstract next(): Promise<string | number | bigint>;
+    abstract current(): Promise<string | number | bigint>;
+    abstract range(count: number): Promise<(number | string | bigint)[]>;
+    static pk<M extends Model>(model: M | Constructor<M>): string;
+}

package/dist/lib/persistence/constants.d.ts

@@ -0,0 +1,22 @@
+export declare enum PersistenceKeys {
+    INDEX = "index",
+    UNIQUE = "unique",
+    ADAPTER = "adapter",
+    INJECTABLE = "decaf_{0}_adapter_for_{1}",
+    TABLE = "table",
+    COLUMN = "column",
+    METADATA = "__metadata",
+    RELATIONS = "__relations",
+    CLAUSE_SEQUENCE = "clause-sequence",
+    CREATED_BY = "ownership.created-by",
+    UPDATED_BY = "ownership.updated-by",
+    ONE_TO_ONE = "relations.one-to-one",
+    ONE_TO_MANY = "relations.one-to-many",
+    MANY_TO_ONE = "relations.many-to-one",
+    POPULATE = "populate"
+}
+export declare enum Roles {
+    ADMIN = "admin",
+    WRITER = "writer",
+    READER = "reader"
+}

package/dist/lib/persistence/decorators.d.ts

@@ -0,0 +1 @@
+export declare function uses(flavour: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/dist/lib/persistence/errors.d.ts

@@ -0,0 +1,7 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export declare class ConnectionError extends BaseError {
+    constructor(msg: string | Error);
+}
+export declare class UnsupportedError extends BaseError {
+    constructor(msg: string | Error);
+}

package/dist/lib/persistence/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Adapter";
+export * from "./constants";
+export * from "./decorators";
+export * from "./errors";
+export * from "./Sequence";

package/dist/lib/query/Clause.d.ts

@@ -0,0 +1,50 @@
+import { Executor } from "../interfaces";
+import { Model, ModelArg } from "@decaf-ts/decorator-validation";
+import { QueryBuilder } from "./options";
+import { Priority } from "./constants";
+import { Statement } from "./Statement";
+import { Paginatable } from "../interfaces/Paginatable";
+import { Paginator } from "./Paginator";
+/**
+ */
+/**
+ * @summary Clause Class
+ * @description Represents a Clause in a {@link Statement}
+ *
+ * @typedef Q Represents que query object the persistence adapter uses
+ *
+ * @param {ModelArg<Clause<Q>>} [clause]
+ *
+ * @class Clause
+ * @extends Model
+ * @implements Executor
+ * @implements QueryBuilder
+ * @abstract
+ *
+ * @category Query
+ * @subcategory Clauses
+ */
+export declare abstract class Clause<Q> extends Model implements Executor, Paginatable, QueryBuilder<Q> {
+    readonly priority: Priority;
+    readonly statement: Statement<Q>;
+    protected constructor(clause?: ModelArg<Clause<Q>>);
+    protected get adapter(): import("..").Adapter<any, Q>;
+    protected get Clauses(): import("./ClauseFactory").ClauseFactory<any, Q>;
+    /**
+     * @summary return the priority of the clause
+     * @see Priority
+     */
+    getPriority(): number;
+    abstract build(previous: Q): Q;
+    /**
+     * @inheritDoc
+     * @abstract
+     */
+    execute<R>(): Promise<R>;
+    /**
+     * @inheritDoc
+     * @abstract
+     */
+    paginate<R>(size: number): Promise<Paginator<R, Q>>;
+    toString(): string;
+}

package/dist/lib/query/ClauseFactory.d.ts

@@ -0,0 +1,71 @@
+import { FromClause } from "./clauses";
+import { GroupByClause } from "./clauses/GroupByClause";
+import { InsertClause } from "./clauses/InsertClause";
+import { LimitClause } from "./clauses/LimitClause";
+import { OffsetClause } from "./clauses/OffsetClause";
+import { OrderByClause } from "./clauses/OrderByClause";
+import { SelectClause } from "./clauses/SelectClause";
+import { ValuesClause } from "./clauses/ValuesClause";
+import { WhereClause } from "./clauses/WhereClause";
+import { Adapter } from "../persistence";
+import { Condition } from "./Condition";
+import { FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
+import { Statement } from "./Statement";
+import { Model } from "@decaf-ts/decorator-validation";
+export declare abstract class ClauseFactory<Y, Q> {
+    protected adapter: Adapter<Y, Q>;
+    /**
+     * @summary Factory method for {@link FromClause}
+     * @param {Statement} statement
+     * @param {FromSelector} selector
+     */
+    abstract from<M extends Model>(statement: Statement<Q>, selector: FromSelector<M>): FromClause<Q, M>;
+    /**
+     * @summary Factory method for {@link GroupByClause}
+     * @param {Statement} statement
+     * @param {GroupBySelector} selector
+     */
+    abstract groupBy(statement: Statement<Q>, selector: GroupBySelector): GroupByClause<Q>;
+    /**
+     * @summary Factory method for {@link InsertClause}
+     * @param {Statement} statement
+     */
+    abstract insert<M extends Model>(): InsertClause<Q, M>;
+    /**
+     * @summary Factory method for {@link LimitClause}
+     * @param {Statement} statement
+     * @param {LimitSelector} selector
+     */
+    abstract limit(statement: Statement<Q>, selector: LimitSelector): LimitClause<Q>;
+    /**
+     * @summary Factory method for {@link OffsetClause}
+     * @param {Statement} statement
+     * @param {OffsetSelector} selector
+     */
+    abstract offset(statement: Statement<Q>, selector: OffsetSelector): OffsetClause<Q>;
+    /**
+     * @summary Factory method for {@link OrderByClause}
+     * @param {Statement} statement
+     * @param {OrderBySelector} selector
+     */
+    abstract orderBy(statement: Statement<Q>, selector: OrderBySelector[]): OrderByClause<Q>;
+    /**
+     * @summary Factory method for {@link SelectClause}
+     * @param {Statement} statement
+     * @param {SelectSelector} [selector]
+     */
+    abstract select<M extends Model>(selector?: SelectSelector): SelectClause<Q, M>;
+    /**
+     * @summary Factory method for {@link ValuesClause}
+     * @param {Statement} statement
+     * @param {M[]} values
+     */
+    abstract values<M extends Model>(statement: Statement<Q>, values: M[]): ValuesClause<Q, M>;
+    /**
+     * @summary Factory method for {@link WhereClause}
+     * @param {Statement} statement
+     * @param {Condition} condition
+     */
+    abstract where(statement: Statement<Q>, condition: Condition): WhereClause<Q>;
+    protected constructor(adapter: Adapter<Y, Q>);
+}