@decaf-ts/core 0.3.36 → 0.3.38

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

@@ -1,15 +0,0 @@
-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/lib/esm/model/decorators.d.ts

@@ -1,75 +0,0 @@
-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/lib/esm/model/index.d.ts

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

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

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

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

@@ -1,86 +0,0 @@
-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/lib/esm/persistence/Sequence.d.ts

@@ -1,22 +0,0 @@
-/**
- * @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/lib/esm/persistence/constants.d.ts

@@ -1,22 +0,0 @@
-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/lib/esm/persistence/decorators.d.ts

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

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

@@ -1,7 +0,0 @@
-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/lib/esm/persistence/index.d.ts

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

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

@@ -1,50 +0,0 @@
-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/lib/esm/query/ClauseFactory.d.ts

@@ -1,71 +0,0 @@
-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>);
-}

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

@@ -1,75 +0,0 @@
-import { AttributeOption, ConditionBuilderOption } from "./options";
-import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
-import { GroupOperator, Operator } from "./constants";
-/**
- * @summary Condition Class
- * @description Represents a logical condition
- *
- * @param {string | Condition} attr1
- * @param {Operator | GroupOperator} operator
- * @param {string | Condition} comparison
- *
- * @class Condition
- * @implements Executor
- *
- * @category Query
- * @subcategory Conditions
- */
-export declare class Condition extends Model {
-    protected attr1?: string | Condition;
-    protected operator?: Operator | GroupOperator;
-    protected comparison?: any;
-    private constructor();
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition
-     */
-    and(condition: Condition): Condition;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition
-     */
-    or(condition: Condition): Condition;
-    /**
-     * @summary excludes a valut from the result
-     * @param val
-     */
-    not(val: any): Condition;
-    /**
-     * @inheritDoc
-     */
-    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
-     */
-    static and(condition1: Condition, condition2: Condition): Condition;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
-     */
-    static or(condition1: Condition, condition2: Condition): Condition;
-    /**
-     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
-     * @param {Condition} condition1
-     * @param {GroupOperator} operator
-     * @param {Condition} condition2
-     */
-    private static group;
-    static attribute(attr: string): AttributeOption;
-    /**
-     * @summary Condition Builder Class
-     * @description provides a simple API to build {@link Condition}s
-     *
-     * @class ConditionBuilder
-     * @implements Builder
-     * @implements AttributeOption
-     *
-     * @category Query
-     * @subcategory Conditions
-     */
-    private static Builder;
-    static get builder(): ConditionBuilderOption;
-}

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

@@ -1,22 +0,0 @@
-import { Statement } from "./Statement";
-export declare abstract class Paginator<V, Q> {
-    protected stat: Statement<Q>;
-    readonly size: number;
-    protected readonly _rawStatement: Q;
-    protected _currentPage: number;
-    protected _totalPages: number;
-    protected _recordCount: number;
-    protected limit: number;
-    private _statement?;
-    get current(): number;
-    get total(): number;
-    get count(): number;
-    get statement(): Q;
-    protected get adapter(): import("..").Adapter<any, Q>;
-    protected constructor(stat: Statement<Q>, size: number, _rawStatement: Q);
-    protected abstract prepare(rawStatement: Q): Q;
-    next(): Promise<V[]>;
-    previous(): Promise<V[]>;
-    protected validatePage(page: number): void;
-    abstract page(page?: number, ...args: any[]): Promise<V[]>;
-}

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

@@ -1,43 +0,0 @@
-import { CountOption, DistinctOption, InsertOption, MaxOption, MinOption, SelectOption } from "./options";
-import { SelectSelector } from "./selectors";
-import { Adapter } from "../persistence";
-import { Model } from "@decaf-ts/decorator-validation";
-/**
- * @summary Helper Class to build queries
- *
- * @param {Database} db
- *
- * @class Query
- *
- * @category Query
- */
-export declare class Query<Q, M extends Model> {
-    private adapter;
-    constructor(adapter: Adapter<any, Q>);
-    /**
-     * @summary Creates a Select Clause
-     * @param {SelectSelector} [selector]
-     */
-    select(selector?: SelectSelector): SelectOption<M>;
-    /**
-     * @summary Creates a Min Clause
-     * @param {SelectSelector} selector
-     */
-    min(selector: SelectSelector): MinOption<M>;
-    /**
-     * @summary Creates a Max Clause
-     * @param {SelectSelector} selector
-     */
-    max(selector: SelectSelector): MaxOption<M>;
-    /**
-     * @summary Creates a Distinct Clause
-     * @param {SelectSelector} selector
-     */
-    distinct(selector: SelectSelector): DistinctOption<M>;
-    /**
-     * @summary Creates a Count Clause
-     * @param {SelectSelector} selector
-     */
-    count(selector?: SelectSelector): CountOption<M>;
-    insert(): InsertOption<M>;
-}

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

@@ -1,55 +0,0 @@
-import { Constructor, Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
-import { Executor, RawExecutor } from "../interfaces";
-import { StatementType } from "./constants";
-import { Clause } from "./Clause";
-import { Adapter } from "../persistence";
-import { Paginator } from "./Paginator";
-/**
- * @summary Statement Class
- * @description holds all the clauses until they can be processed
- *
- * @param {ModelArg} [statement]
- *
- * @class Statement
- * @extends Model
- * @implements Executor
- * @implements RawExecutor
- *
- * @category Query
- */
-export declare abstract class Statement<Q> extends Model implements Executor, RawExecutor<Q> {
-    protected clauses?: Clause<any>[];
-    protected adapter: Adapter<any, Q>;
-    protected target?: Constructor<any>;
-    protected fullRecord: boolean;
-    protected type?: string;
-    protected constructor(db: Adapter<any, Q>);
-    protected build(): Q;
-    /**
-     * @inheritDoc
-     */
-    execute<Y>(): Promise<Y>;
-    /**
-     * @inheritDoc
-     */
-    abstract paginate<Y>(size: number): Promise<Paginator<Y, Q>>;
-    raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
-    /**
-     * @inheritDoc
-     */
-    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
-    /**
-     * @summary Adds a clause to the Statement
-     * @param {Clause} clause
-     */
-    addClause(clause: Clause<Q>): void;
-    getAdapter(): Adapter<any, Q>;
-    /**
-     * @summary Defines the output class (when existing)
-     * @param {Constructor} clazz
-     */
-    setTarget(clazz: Constructor<any>): void;
-    getTarget(): Constructor<any>;
-    setFullRecord(): void;
-    setMode(type: StatementType): void;
-}

package/lib/esm/query/clauses/FromClause.d.ts

@@ -1,45 +0,0 @@
-import { FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector } from "../selectors";
-import { LimitOption, OffsetOption, OrderAndGroupOption, WhereOption } from "../options";
-import { SelectorBasedClause } from "./SelectorBasedClause";
-import { Executor } from "../../interfaces";
-import { Condition } from "../Condition";
-import { Model, ModelArg } from "@decaf-ts/decorator-validation";
-/**
- * @summary The FROM clause
- *
- * @param {ModelArg} [clause]
- *
- * @class FromClause
- * @extends SelectorBasedClause
- * @implements WhereOption
- *
- * @category Query
- * @subcategory Clauses
- */
-export declare abstract class FromClause<Q, M extends Model> extends SelectorBasedClause<Q, FromSelector<M>> implements WhereOption {
-    protected constructor(clause?: ModelArg<FromClause<Q, M>>);
-    /**
-     * @inheritDoc
-     */
-    abstract build(query: Q): Q;
-    /**
-     * @inheritDoc
-     */
-    where(condition: Condition): OrderAndGroupOption;
-    /**
-     * @inheritDoc
-     */
-    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
-    /**
-     * @inheritDoc
-     */
-    groupBy(selector: GroupBySelector): Executor;
-    /**
-     * @inheritDoc
-     */
-    limit(selector: LimitSelector): OffsetOption;
-    /**
-     * @inheritDoc
-     */
-    offset(selector: OffsetSelector): Executor;
-}

package/lib/esm/query/clauses/GroupByClause.d.ts

@@ -1,21 +0,0 @@
-import { ModelArg } from "@decaf-ts/decorator-validation";
-import { GroupBySelector } from "../selectors";
-import { SelectorBasedClause } from "./SelectorBasedClause";
-/**
- * @summary The GROUP BY clause
- *
- * @param {ClauseArg} [clause]
- *
- * @class GroupByClause
- * @extends SelectorBasedClause
- *
- * @category Query
- * @subcategory Clauses
- */
-export declare abstract class GroupByClause<Q> extends SelectorBasedClause<Q, GroupBySelector> {
-    protected constructor(clause?: ModelArg<GroupByClause<Q>>);
-    /**
-     * @inheritDoc
-     */
-    abstract build(query: Q): Q;
-}