@spinajs/orm-sql 2.0.38 → 2.0.39

package/lib/orm/src/builders.d.ts

@@ -0,0 +1,636 @@
+import { Container, Constructor, IContainer } from '@spinajs/di';
+import { ColumnType, QueryMethod, SordOrder, WhereBoolean, SqlOperator } from './enums';
+import { IColumnsBuilder, ICompilerOutput, ILimitBuilder, IOrderByBuilder, IQueryBuilder, IQueryLimit, ISort, IWhereBuilder, QueryContext, IJoinBuilder, IBuilderMiddleware, IWithRecursiveBuilder, ReferentialAction, IGroupByBuilder, IUpdateResult, DefaultValueBuilder, ColumnAlterationType, ISelectBuilderExtensions, QueryMiddleware } from './interfaces';
+import { ColumnStatement, IQueryStatement, RawQueryStatement, Wrap } from './statements';
+import { PartialModel, PickRelations, WhereFunction } from './types';
+import { OrmDriver } from './driver';
+import { ModelBase } from './model';
+import { OrmRelation, IOrmRelation, Relation } from './relations';
+import { DateTime } from 'luxon';
+/**
+ *  Trick typescript by using the inbuilt interface inheritance and declaration merging
+ *  for builder classes.
+ *
+ *  We use mixins to extend functionality of builder eg. insert query builder uses function from columns builder
+ *  and so on...
+ */
+export interface InsertQueryBuilder extends IColumnsBuilder {
+}
+export interface DeleteQueryBuilder<T> extends IWhereBuilder<T>, ILimitBuilder<T> {
+}
+export interface UpdateQueryBuilder<T> extends IColumnsBuilder, IWhereBuilder<T> {
+}
+export interface SelectQueryBuilder<T> extends IColumnsBuilder, IOrderByBuilder, ILimitBuilder<T>, IWhereBuilder<T>, IJoinBuilder, IWithRecursiveBuilder, IGroupByBuilder, ISelectBuilderExtensions {
+}
+export declare class Builder<T = any> implements PromiseLike<T> {
+    protected _driver: OrmDriver;
+    protected _container: IContainer;
+    protected _model?: Constructor<ModelBase>;
+    protected _nonSelect: boolean;
+    protected _middlewares: IBuilderMiddleware<T>[];
+    protected _queryMiddlewares: QueryMiddleware[];
+    protected _asRaw: boolean;
+    QueryContext: QueryContext;
+    get Driver(): OrmDriver;
+    get Container(): IContainer;
+    get Model(): Constructor<ModelBase> | undefined;
+    constructor(container: IContainer, driver: OrmDriver, model?: Constructor<ModelBase>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
+    middleware(middleware: IBuilderMiddleware<T>): this;
+    /**
+     * Builds query that is ready to use in DB
+     */
+    toDB(): ICompilerOutput | ICompilerOutput[];
+}
+/**
+ * Base class for queires. Implements basic query functionality
+ *
+ */
+export declare class QueryBuilder<T = any> extends Builder<T> implements IQueryBuilder {
+    protected _method: QueryMethod;
+    protected _table: string;
+    protected _tableAlias: string;
+    protected _database: string;
+    constructor(container: IContainer, driver: OrmDriver, model?: Constructor<ModelBase>);
+    /**
+     * SQL table name that query is executed on
+     *
+     * @example
+     * SELECT * FROM `users`
+     */
+    get Table(): string;
+    /**
+     * DB table alias
+     */
+    get TableAlias(): string;
+    /**
+     * SQL schema/database name that query is executed on.
+     *
+     * @example
+     * SELECT * FROM `spinejs`.`users` as u
+     */
+    get Database(): string;
+    /**
+     * Sets schema to this query.
+     *
+     * @param database - schema or database name in database
+     */
+    database(database: string): this;
+    /**
+     * Sets table that query is executed on
+     *
+     * @param table - sql table name
+     * @param alias - sql table alias
+     *
+     * @example
+     *
+     * this.setTable("user","u")
+     *
+     */
+    setTable(table: string, alias?: string): this;
+    /**
+     * Sets table alias for query
+     *
+     * @param alias - sql table alias
+     */
+    setAlias(alias: string): this;
+    from(table: string, alias?: string): this;
+}
+export declare class LimitBuilder<T> implements ILimitBuilder<T> {
+    protected _first: boolean;
+    protected _limit: IQueryLimit;
+    constructor();
+    take(count: number): this;
+    skip(count: number): this;
+    first(): Promise<any>;
+    firstOrFail(): Promise<any>;
+    orThrow(error: Error): Promise<any>;
+    firstOrThrow(error: Error): Promise<any>;
+    getLimits(): IQueryLimit;
+}
+export declare class OrderByBuilder implements IOrderByBuilder {
+    protected _sort: ISort;
+    constructor();
+    order(column: string, direction: SordOrder): this;
+    orderBy(column: string): this;
+    orderByDescending(column: string): this;
+    getSort(): ISort;
+}
+export declare class ColumnsBuilder implements IColumnsBuilder {
+    protected _container: Container;
+    protected _columns: IQueryStatement[];
+    protected _tableAlias: string;
+    protected _model?: Constructor<ModelBase>;
+    constructor();
+    /**
+     * Clears all select clauses from the query.
+     *
+     * @example
+     *
+     * query.columns()
+     *
+     */
+    clearColumns(): this;
+    columns(names: string[]): this;
+    select(column: string | RawQuery | Map<string, string>, alias?: string): this;
+    getColumns(): IQueryStatement[];
+}
+export declare class RawQuery {
+    get Query(): string;
+    get Bindings(): any[];
+    static create(query: string, bindings?: any[]): RawQuery;
+    private _query;
+    private _bindings;
+    constructor(query: string, bindings?: any[]);
+}
+export declare class GroupByBuilder implements IGroupByBuilder {
+    protected _container: Container;
+    protected _groupStatements: IQueryStatement[];
+    get GroupStatements(): IQueryStatement[];
+    clearGroupBy(): this;
+    groupBy(expression: string | RawQuery): this;
+}
+export declare class JoinBuilder implements IJoinBuilder {
+    protected _model?: Constructor<ModelBase>;
+    get JoinStatements(): IQueryStatement[];
+    protected _joinStatements: IQueryStatement[];
+    protected _container: Container;
+    protected _tableAlias: string;
+    constructor(container: Container);
+    clearJoins(): this;
+    innerJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    innerJoin(query: RawQuery): this;
+    innerJoin(table: string, foreignKey: string, primaryKey: string): this;
+    leftJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    leftJoin(query: RawQuery): this;
+    leftJoin(table: string, foreignKey: string, primaryKey: string): this;
+    leftOuterJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    leftOuterJoin(query: RawQuery): this;
+    leftOuterJoin(table: string, foreignKey: string, primaryKey: string): this;
+    rightJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    rightJoin(query: RawQuery): this;
+    rightJoin(table: string, foreignKey: string, primaryKey: string): this;
+    rightOuterJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    rightOuterJoin(query: RawQuery): this;
+    rightOuterJoin(table: string, foreignKey: string, primaryKey: string): this;
+    fullOuterJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    fullOuterJoin(query: RawQuery): this;
+    fullOuterJoin(table: string, foreignKey: string, primaryKey: string): this;
+    crossJoin<R extends ModelBase>(model: R, where?: (this: SelectQueryBuilder<R>) => void): this;
+    crossJoin(query: RawQuery): this;
+    crossJoin(table: string, foreignKey: string, primaryKey: string): this;
+    private addJoinStatement;
+}
+export declare class WithRecursiveBuilder implements IWithRecursiveBuilder {
+    protected _container: Container;
+    protected _cteStatement: IQueryStatement;
+    get CteRecursive(): IQueryStatement;
+    withRecursive(rcKeyName: string, pkName: string): this;
+}
+export declare class WhereBuilder<T> implements IWhereBuilder<T> {
+    protected _statements: IQueryStatement[];
+    protected _boolean: WhereBoolean;
+    protected _container: Container;
+    protected _tableAlias: string;
+    protected _model: Constructor<ModelBase>;
+    get Statements(): IQueryStatement[];
+    get Op(): WhereBoolean;
+    constructor(container: Container, tableAlias?: string);
+    where(column: string | boolean | WhereFunction<T> | RawQuery | Wrap | PartialModel<T> | PickRelations<T, Relation<any, any>>, operator?: SqlOperator | any, value?: any): this;
+    orWhere(column: string | boolean | WhereFunction<T> | {}, ..._args: any[]): this;
+    andWhere(column: string | boolean | WhereFunction<T> | {}, ..._args: any[]): this;
+    whereObject(obj: any): this;
+    whereNotNull(column: string): this;
+    whereNull(column: string): this;
+    whereNot(column: string, val: any): this;
+    whereIn(column: string, val: any[]): this;
+    whereNotIn(column: string, val: any[]): this;
+    whereExist(query: SelectQueryBuilder): this;
+    whereNotExists(query: SelectQueryBuilder): this;
+    whereBetween(column: string, val: any[]): this;
+    whereNotBetween(column: string, val: any[]): this;
+    whereInSet(column: string, val: any[]): this;
+    whereNotInSet(column: string, val: any[]): this;
+    clearWhere(): this;
+}
+export declare class SelectQueryBuilder<T = any> extends QueryBuilder<T> {
+    /**
+     * column query props
+     */
+    protected _distinct: boolean;
+    protected _columns: IQueryStatement[];
+    /**
+     * limit query props
+     */
+    protected _fail: boolean;
+    protected _first: boolean;
+    protected _limit: IQueryLimit;
+    /**
+     * order by query props
+     */
+    protected _sort: ISort;
+    /**
+     * where query props
+     */
+    protected _statements: IQueryStatement[];
+    protected _boolean: WhereBoolean;
+    protected _joinStatements: IQueryStatement[];
+    protected _groupStatements: IQueryStatement[];
+    protected _cteStatement: IQueryStatement;
+    protected _relations: IOrmRelation[];
+    protected _owner: IOrmRelation;
+    get Owner(): IOrmRelation;
+    this: this;
+    get IsDistinct(): boolean;
+    get Relations(): IOrmRelation[];
+    constructor(container: IContainer, driver: OrmDriver, model?: Constructor<any>, owner?: IOrmRelation);
+    asRaw<T>(): Promise<T>;
+    setAlias(alias: string): this;
+    clone(): this;
+    populate<R = this>(relation: string, callback?: (this: SelectQueryBuilder<R>, relation: OrmRelation) => void): this;
+    mergeStatements(builder: SelectQueryBuilder): void;
+    min(column: string, as?: string): this;
+    max(column: string, as?: string): this;
+    count(column: string, as?: string): this;
+    sum(column: string, as?: string): this;
+    avg(column: string, as?: string): this;
+    distinct(): this;
+    toDB(): ICompilerOutput;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
+    execute(): Promise<T>;
+}
+export declare class DeleteQueryBuilder<T> extends QueryBuilder<IUpdateResult> {
+    /**
+     * where query props
+     */
+    protected _statements: IQueryStatement[];
+    protected _boolean: WhereBoolean;
+    protected _limit: IQueryLimit;
+    private this;
+    constructor(container: Container, driver: OrmDriver, model: Constructor<any>);
+    toDB(): ICompilerOutput;
+}
+export declare class OnDuplicateQueryBuilder {
+    protected _column: string[];
+    protected _parent: InsertQueryBuilder;
+    protected _columnsToUpdate: Array<string | RawQuery>;
+    protected _container: IContainer;
+    constructor(container: IContainer, insertQueryBuilder: InsertQueryBuilder, column?: string | string[]);
+    getColumn(): string[];
+    getColumnsToUpdate(): (string | RawQuery)[];
+    getParent(): InsertQueryBuilder;
+    update(columns: string[] | RawQuery[]): this;
+    then<TResult1, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
+    toDB(): ICompilerOutput;
+}
+export declare class UpdateQueryBuilder<T> extends QueryBuilder<IUpdateResult> {
+    /**
+     * where query props
+     */
+    protected _statements: IQueryStatement[];
+    protected _boolean: WhereBoolean;
+    protected _value: {};
+    get Value(): {};
+    this: this;
+    constructor(container: Container, driver: OrmDriver, model: Constructor<any>);
+    in(name: string): this;
+    update(value: {}): this;
+    toDB(): ICompilerOutput;
+}
+export declare class InsertQueryBuilder extends QueryBuilder<IUpdateResult> {
+    DuplicateQueryBuilder: OnDuplicateQueryBuilder;
+    protected _values: any[][];
+    protected _columns: ColumnStatement[];
+    protected _ignore: boolean;
+    protected _update: boolean;
+    protected _replace: boolean;
+    this: this;
+    get Values(): any[][];
+    get Ignore(): boolean;
+    get Update(): boolean;
+    get Replace(): boolean;
+    constructor(container: Container, driver: OrmDriver, model: Constructor<any>);
+    /**
+     * Sets insert to ignore on duplicate
+     */
+    orIgnore(): this;
+    orReplace(): this;
+    values(data: {} | Array<{}>): this;
+    into(table: string, schema?: string): this;
+    onDuplicate(column?: string | string[]): OnDuplicateQueryBuilder;
+    toDB(): ICompilerOutput;
+}
+export declare class IndexQueryBuilder extends Builder {
+    Name: string;
+    Unique: boolean;
+    Table: string;
+    Columns: string[];
+    constructor(container: Container, driver: OrmDriver);
+    name(name: string): this;
+    unique(): this;
+    table(name: string): this;
+    columns(colNames: string[]): this;
+    toDB(): ICompilerOutput;
+}
+export declare class ForeignKeyBuilder {
+    ForeignKeyField: string;
+    Table: string;
+    PrimaryKey: string;
+    OnDeleteAction: ReferentialAction;
+    OnUpdateAction: ReferentialAction;
+    constructor();
+    /**
+     *
+     * Referenced field in child table
+     *
+     * @param fkName - name of foreign field in child table
+     */
+    foreignKey(fkName: string): this;
+    /**
+     *
+     * Referenced parent table & key
+     *
+     * @param table - parent table
+     * @param pKey - parant table key field
+     */
+    references(table: string, pKey: string): this;
+    /**
+     *
+     * On delete action
+     *
+     * @param action - action to take on delete
+     */
+    onDelete(action: ReferentialAction): this;
+    /**
+     *
+     * On update action
+     *
+     * @param action - action to take on update
+     */
+    onUpdate(action: ReferentialAction): this;
+    /**
+     * Shorhand for on update and on delete cascade settings
+     */
+    cascade(): this;
+}
+export declare class ColumnQueryBuilder {
+    protected container: IContainer;
+    Name: string;
+    Unique: boolean;
+    Unsigned: boolean;
+    AutoIncrement: boolean;
+    Default: DefaultValueBuilder<ColumnQueryBuilder>;
+    PrimaryKey: boolean;
+    Comment: string;
+    Charset: string;
+    Collation: string;
+    NotNull: boolean;
+    Type: ColumnType;
+    Args: any[];
+    constructor(container: IContainer, name: string, type: ColumnType, ...args: any[]);
+    notNull(): this;
+    unique(): this;
+    unsigned(): this;
+    autoIncrement(): this;
+    default(): DefaultValueBuilder<ColumnQueryBuilder>;
+    primaryKey(): this;
+    comment(comment: string): this;
+    charset(charset: string): this;
+    collation(collation: string): this;
+}
+export declare class AlterColumnQueryBuilder extends ColumnQueryBuilder {
+    AlterType: ColumnAlterationType;
+    AfterColumn: string;
+    OldName: string;
+    constructor(container: IContainer, name: string, type: ColumnType, ...args: any[]);
+    addColumn(): this;
+    modify(): this;
+    rename(newName: string): this;
+    after(columnName: string): this;
+}
+export declare class TableExistsQueryBuilder extends QueryBuilder {
+    constructor(container: Container, driver: OrmDriver, name: string);
+    toDB(): ICompilerOutput;
+}
+export declare class DropTableQueryBuilder extends QueryBuilder {
+    Exists: boolean;
+    constructor(container: Container, driver: OrmDriver, name: string, database?: string);
+    ifExists(): this;
+    toDB(): ICompilerOutput;
+}
+export declare class AlterTableQueryBuilder extends QueryBuilder {
+    protected _columns: ColumnQueryBuilder[];
+    NewTableName: string;
+    DroppedColumns: string[];
+    get Columns(): ColumnQueryBuilder[];
+    constructor(container: Container, driver: OrmDriver, name: string);
+    int: (name: string) => AlterColumnQueryBuilder;
+    bigint: (name: string) => AlterColumnQueryBuilder;
+    tinyint: (name: string) => AlterColumnQueryBuilder;
+    smallint: (name: string) => AlterColumnQueryBuilder;
+    mediumint: (name: string) => AlterColumnQueryBuilder;
+    text: (name: string) => AlterColumnQueryBuilder;
+    tinytext: (name: string) => AlterColumnQueryBuilder;
+    mediumtext: (name: string) => AlterColumnQueryBuilder;
+    smalltext: (name: string) => AlterColumnQueryBuilder;
+    longtext: (name: string) => AlterColumnQueryBuilder;
+    string: (name: string, length?: number) => AlterColumnQueryBuilder;
+    float: (name: string, precision?: number, scale?: number) => AlterColumnQueryBuilder;
+    double: (name: string, precision?: number, scale?: number) => AlterColumnQueryBuilder;
+    decimal: (name: string, precision?: number, scale?: number) => AlterColumnQueryBuilder;
+    boolean: (name: string) => AlterColumnQueryBuilder;
+    bit: (name: string) => AlterColumnQueryBuilder;
+    date: (name: string) => AlterColumnQueryBuilder;
+    dateTime: (name: string) => AlterColumnQueryBuilder;
+    time: (name: string) => AlterColumnQueryBuilder;
+    timestamp: (name: string) => AlterColumnQueryBuilder;
+    enum: (name: string, values: any[]) => AlterColumnQueryBuilder;
+    json: (name: string) => AlterColumnQueryBuilder;
+    binary: (name: string, size: number) => AlterColumnQueryBuilder;
+    tinyblob: (name: string) => AlterColumnQueryBuilder;
+    mediumblob: (name: string) => AlterColumnQueryBuilder;
+    longblob: (name: string) => AlterColumnQueryBuilder;
+    /**
+     * Renames table
+     *
+     * @param newTableName - new table name
+     */
+    rename(newTableName: string): void;
+    dropColumn(column: string): void;
+    toDB(): ICompilerOutput[];
+}
+export declare class TableQueryBuilder extends QueryBuilder {
+    int: (name: string) => ColumnQueryBuilder;
+    bigint: (name: string) => ColumnQueryBuilder;
+    tinyint: (name: string) => ColumnQueryBuilder;
+    smallint: (name: string) => ColumnQueryBuilder;
+    mediumint: (name: string) => ColumnQueryBuilder;
+    text: (name: string) => ColumnQueryBuilder;
+    tinytext: (name: string) => ColumnQueryBuilder;
+    mediumtext: (name: string) => ColumnQueryBuilder;
+    smalltext: (name: string) => ColumnQueryBuilder;
+    longtext: (name: string) => ColumnQueryBuilder;
+    string: (name: string, length?: number) => ColumnQueryBuilder;
+    /**
+     * Alias for string(name, 36 )
+     */
+    uuid(name: string): ColumnQueryBuilder;
+    float: (name: string, precision?: number, scale?: number) => ColumnQueryBuilder;
+    double: (name: string, precision?: number, scale?: number) => ColumnQueryBuilder;
+    decimal: (name: string, precision?: number, scale?: number) => ColumnQueryBuilder;
+    boolean: (name: string) => ColumnQueryBuilder;
+    bit: (name: string) => ColumnQueryBuilder;
+    date: (name: string) => ColumnQueryBuilder;
+    dateTime: (name: string) => ColumnQueryBuilder;
+    time: (name: string) => ColumnQueryBuilder;
+    timestamp: (name: string) => ColumnQueryBuilder;
+    enum: (name: string, values: any[]) => ColumnQueryBuilder;
+    json: (name: string) => ColumnQueryBuilder;
+    binary: (name: string, size: number) => ColumnQueryBuilder;
+    tinyblob: (name: string) => ColumnQueryBuilder;
+    mediumblob: (name: string) => ColumnQueryBuilder;
+    longblob: (name: string) => ColumnQueryBuilder;
+    ifExists(): TableQueryBuilder;
+    /**
+     * Mark table as temporary
+     */
+    temporary(): TableQueryBuilder;
+    /**
+     * Turn on history trackign for this table
+     * Each change & row will be tracked, and all history of changes can be accessed
+     */
+    trackHistory(): this;
+    set: (name: string, allowed: string[]) => ColumnQueryBuilder;
+    get Columns(): ColumnQueryBuilder[];
+    get ForeignKeys(): ForeignKeyBuilder[];
+    protected _columns: ColumnQueryBuilder[];
+    protected _foreignKeys: ForeignKeyBuilder[];
+    protected _comment: string;
+    protected _charset: string;
+    protected _checkExists: boolean;
+    protected _temporary: boolean;
+    protected _trackHistory: boolean;
+    get CheckExists(): boolean;
+    get Temporary(): boolean;
+    get TrackHistory(): boolean;
+    constructor(container: Container, driver: OrmDriver, name: string);
+    increments(name: string): ColumnQueryBuilder;
+    comment(comment: string): void;
+    charset(charset: string): void;
+    foreignKey(foreignKey: string): ForeignKeyBuilder;
+    toDB(): ICompilerOutput | ICompilerOutput[];
+}
+export declare class TruncateTableQueryBuilder extends QueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    constructor(container: Container, driver: OrmDriver);
+    toDB(): ICompilerOutput;
+}
+export declare class CloneTableQueryBuilder extends QueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    protected _cloneSrc: string;
+    protected _temporary: boolean;
+    protected _shallow: boolean;
+    protected _filter: SelectQueryBuilder;
+    get CloneSource(): string;
+    get Temporary(): boolean;
+    get Shallow(): boolean;
+    get Filter(): SelectQueryBuilder<any>;
+    constructor(container: Container, driver: OrmDriver);
+    /**
+     * Clones table structure without data
+     * Shorthand for createTable(( table) => table.clone("new"));
+     *
+     * @param srcTable - source table name
+     * @param newTable - target table name
+     */
+    shallowClone(srcTable: string, newTable: string): this;
+    /**
+     * Clones table with data
+     *
+     * @param srcTable - source table name
+     * @param newTable - target table name
+     * @param filter - data filter, set null if all data is to be cloned
+     */
+    deepClone(srcTable: string, newTable: string, filter?: (query: SelectQueryBuilder) => void): Promise<any>;
+    toDB(): ICompilerOutput[];
+}
+export declare class EventIntervalDesc {
+    Year: number;
+    Month: number;
+    Minute: number;
+    Hour: number;
+    Second: number;
+}
+export declare class EventQueryBuilder extends QueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    Name: string;
+    EveryInterval: EventIntervalDesc;
+    FromNowInverval: EventIntervalDesc;
+    Comment: string;
+    At: DateTime;
+    RawSql: RawQueryStatement;
+    Queries: QueryBuilder[];
+    constructor(container: Container, driver: OrmDriver, Name: string);
+    /**
+     * execute every time with specified interval ( days, hours, seconds, minutes etc)
+     */
+    every(): EventIntervalDesc;
+    /**
+     *
+     * Execute at specific time
+     *
+     * @param dateTime - specific time
+     */
+    at(dateTime: DateTime): void;
+    /**
+     * execute once at specific interfal from now eg. now + 1 day
+     */
+    fromNow(): EventIntervalDesc;
+    /**
+     *
+     * @param sql - code to execute,  could be raw sql query, single builder, or multiple builders that will be executed on by one
+     */
+    do(sql: RawQueryStatement | QueryBuilder[] | QueryBuilder): void;
+    /**
+     *
+     * Add comment to schedule for documentation. It is passed to sql engine
+     *
+     * @param comment - comment text
+     */
+    comment(comment: string): void;
+    toDB(): ICompilerOutput[];
+}
+export declare class DropEventQueryBuilder extends QueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    Name: string;
+    constructor(container: Container, driver: OrmDriver, Name: string);
+    toDB(): ICompilerOutput[];
+}
+/**
+ * Creates schedule job in database engine.
+ * Note, some engines does not support this, so it will implemented
+ * as nodejs interval
+ */
+export declare class ScheduleQueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    constructor(container: Container, driver: OrmDriver);
+    create(name: string, callback: (event: EventQueryBuilder) => void): EventQueryBuilder;
+    drop(name: string): DropEventQueryBuilder;
+}
+export declare class SchemaQueryBuilder {
+    protected container: Container;
+    protected driver: OrmDriver;
+    constructor(container: Container, driver: OrmDriver);
+    createTable(name: string, callback: (table: TableQueryBuilder) => void): TableQueryBuilder;
+    cloneTable(callback: (clone: CloneTableQueryBuilder) => void): CloneTableQueryBuilder;
+    alterTable(name: string, callback: (table: AlterTableQueryBuilder) => void): AlterTableQueryBuilder;
+    dropTable(name: string, schema?: string): DropTableQueryBuilder;
+    tableExists(name: string, schema?: string): Promise<boolean>;
+    event(name: string): Promise<any>;
+    dropEvent(name: string): Promise<any>;
+}