@adonisjs/lucid

  • Version 16.3.2
  • Published
  • 883 kB
  • 13 dependencies
  • MIT license

Install

npm i @adonisjs/lucid
yarn add @adonisjs/lucid
pnpm add @adonisjs/lucid

Overview

SQL ORM built on top of Active Record pattern

Index

Namespaces

Namespaces

namespace @ioc:Adonis/Core/Application

module '@ioc:Adonis/Core/Application' {}

    interface ContainerBindings

    interface ContainerBindings {}

      property 'Adonis/Lucid/Database'

      'Adonis/Lucid/Database': DatabaseContract;

        property 'Adonis/Lucid/Factory'

        'Adonis/Lucid/Factory': FactoryManagerContract;

          property 'Adonis/Lucid/Migrator'

          'Adonis/Lucid/Migrator': typeof Migrator;

            property 'Adonis/Lucid/Orm'

            'Adonis/Lucid/Orm': typeof Orm;

              property 'Adonis/Lucid/Schema'

              'Adonis/Lucid/Schema': SchemaConstructorContract;

                property 'Adonis/Lucid/Seeder'

                'Adonis/Lucid/Seeder': SeederConstructorContract;

                  namespace @ioc:Adonis/Core/Event

                  module '@ioc:Adonis/Core/Event' {}

                    interface EventsList

                    interface EventsList {}

                      property 'db:query'

                      'db:query': DbQueryEventNode;

                        namespace @ioc:Adonis/Core/Validator

                        module '@ioc:Adonis/Core/Validator' {}

                          interface Rules

                          interface Rules {}

                            method exists

                            exists: (options: DbRowCheckOptions) => any;

                              method unique

                              unique: (options: DbRowCheckOptions) => any;

                                type DbRowCheckOptions

                                type DbRowCheckOptions = {
                                table: string;
                                column: string;
                                dateFormat?: string;
                                connection?: string;
                                caseInsensitive?: boolean;
                                constraints?: {
                                [key: string]: any;
                                };
                                where?: {
                                [key: string]: any;
                                };
                                whereNot?: {
                                [key: string]: any;
                                };
                                };

                                  namespace @ioc:Adonis/Lucid/Database

                                  module '@ioc:Adonis/Lucid/Database' {}

                                    interface Aggregate

                                    interface Aggregate<Builder extends ChainableContract> {}
                                    • Possible signatures for aggregate functions. Aggregates will push to the result set. Unlike knex, we force defining aliases for each aggregate.

                                    call signature

                                    (column: OneOrMany<ValueWithSubQueries<string>>, alias?: string): Builder;
                                    • Accepting column with the alias for the count.

                                    call signature

                                    (columns: Dictionary<OneOrMany<ValueWithSubQueries<string>>, string>): Builder;
                                    • Accepting an object for multiple counts in a single query.

                                    interface ChainableContract

                                    interface ChainableContract {}
                                    • The chainable contract has all the methods that can be chained to build a query. This interface will never have any methods to execute a query.

                                    property andHaving

                                    andHaving: Having<this>;

                                      property andHavingBetween

                                      andHavingBetween: HavingBetween<this>;

                                        property andHavingExists

                                        andHavingExists: HavingExists<this>;

                                          property andHavingIn

                                          andHavingIn: HavingIn<this>;

                                            property andHavingNotBetween

                                            andHavingNotBetween: HavingBetween<this>;

                                              property andHavingNotExists

                                              andHavingNotExists: HavingExists<this>;

                                                property andHavingNotIn

                                                andHavingNotIn: HavingIn<this>;

                                                  property andHavingNotNull

                                                  andHavingNotNull: HavingNull<this>;

                                                    property andHavingNull

                                                    andHavingNull: HavingNull<this>;

                                                      property andHavingRaw

                                                      andHavingRaw: RawQueryFn<this>;

                                                        property andWhere

                                                        andWhere: Where<this>;

                                                          property andWhereBetween

                                                          andWhereBetween: WhereBetween<this>;

                                                            property andWhereColumn

                                                            andWhereColumn: WhereColumn<this>;

                                                              property andWhereExists

                                                              andWhereExists: WhereExists<this>;

                                                                property andWhereIn

                                                                andWhereIn: WhereIn<this>;

                                                                  property andWhereNot

                                                                  andWhereNot: Where<this>;

                                                                    property andWhereNotBetween

                                                                    andWhereNotBetween: WhereBetween<this>;

                                                                      property andWhereNotColumn

                                                                      andWhereNotColumn: WhereColumn<this>;

                                                                        property andWhereNotExists

                                                                        andWhereNotExists: WhereExists<this>;

                                                                          property andWhereNotIn

                                                                          andWhereNotIn: WhereIn<this>;

                                                                            property andWhereNotNull

                                                                            andWhereNotNull: WhereNull<this>;

                                                                              property andWhereNull

                                                                              andWhereNull: WhereNull<this>;

                                                                                property andWhereRaw

                                                                                andWhereRaw: RawQueryFn<this>;

                                                                                  property columns

                                                                                  columns: (string | Knex.QueryBuilder | Knex.RawQueryBuilder)[];

                                                                                    property crossJoin

                                                                                    crossJoin: Join<this>;

                                                                                      property distinct

                                                                                      distinct: Distinct<this>;

                                                                                        property distinctOn

                                                                                        distinctOn: Distinct<this>;

                                                                                          property from

                                                                                          from: FromTable<this>;

                                                                                            property fullOuterJoin

                                                                                            fullOuterJoin: Join<this>;

                                                                                              property groupBy

                                                                                              groupBy: GroupBy<this>;

                                                                                                property groupByRaw

                                                                                                groupByRaw: RawQueryFn<this>;

                                                                                                  property hasAggregates

                                                                                                  hasAggregates: boolean;

                                                                                                    property hasGroupBy

                                                                                                    hasGroupBy: boolean;

                                                                                                      property hasUnion

                                                                                                      hasUnion: boolean;

                                                                                                        property having

                                                                                                        having: Having<this>;

                                                                                                          property havingBetween

                                                                                                          havingBetween: HavingBetween<this>;

                                                                                                            property havingExists

                                                                                                            havingExists: HavingExists<this>;

                                                                                                              property havingIn

                                                                                                              havingIn: HavingIn<this>;

                                                                                                                property havingNotBetween

                                                                                                                havingNotBetween: HavingBetween<this>;

                                                                                                                  property havingNotExists

                                                                                                                  havingNotExists: HavingExists<this>;

                                                                                                                    property havingNotIn

                                                                                                                    havingNotIn: HavingIn<this>;

                                                                                                                      property havingNotNull

                                                                                                                      havingNotNull: HavingNull<this>;

                                                                                                                        property havingNull

                                                                                                                        havingNull: HavingNull<this>;

                                                                                                                          property havingRaw

                                                                                                                          havingRaw: RawQueryFn<this>;

                                                                                                                            property innerJoin

                                                                                                                            innerJoin: Join<this>;

                                                                                                                              property intersect

                                                                                                                              intersect: Intersect<this>;

                                                                                                                                property join

                                                                                                                                join: Join<this>;

                                                                                                                                  property joinRaw

                                                                                                                                  joinRaw: RawQueryFn<this>;

                                                                                                                                    property keysResolver

                                                                                                                                    keysResolver?: (columnName: string) => string;

                                                                                                                                      property knexQuery

                                                                                                                                      knexQuery: Knex.QueryBuilder;

                                                                                                                                        property leftJoin

                                                                                                                                        leftJoin: Join<this>;

                                                                                                                                          property leftOuterJoin

                                                                                                                                          leftOuterJoin: Join<this>;

                                                                                                                                            property orderBy

                                                                                                                                            orderBy: OrderBy<this>;

                                                                                                                                              property orderByRaw

                                                                                                                                              orderByRaw: RawQueryFn<this>;

                                                                                                                                                property orHaving

                                                                                                                                                orHaving: Having<this>;

                                                                                                                                                  property orHavingBetween

                                                                                                                                                  orHavingBetween: HavingBetween<this>;

                                                                                                                                                    property orHavingExists

                                                                                                                                                    orHavingExists: HavingExists<this>;

                                                                                                                                                      property orHavingIn

                                                                                                                                                      orHavingIn: HavingIn<this>;

                                                                                                                                                        property orHavingNotBetween

                                                                                                                                                        orHavingNotBetween: HavingBetween<this>;

                                                                                                                                                          property orHavingNotExists

                                                                                                                                                          orHavingNotExists: HavingExists<this>;

                                                                                                                                                            property orHavingNotIn

                                                                                                                                                            orHavingNotIn: HavingIn<this>;

                                                                                                                                                              property orHavingNotNull

                                                                                                                                                              orHavingNotNull: HavingNull<this>;

                                                                                                                                                                property orHavingNull

                                                                                                                                                                orHavingNull: HavingNull<this>;

                                                                                                                                                                  property orHavingRaw

                                                                                                                                                                  orHavingRaw: RawQueryFn<this>;

                                                                                                                                                                    property orWhere

                                                                                                                                                                    orWhere: Where<this>;

                                                                                                                                                                      property orWhereBetween

                                                                                                                                                                      orWhereBetween: WhereBetween<this>;

                                                                                                                                                                        property orWhereColumn

                                                                                                                                                                        orWhereColumn: WhereColumn<this>;

                                                                                                                                                                          property orWhereExists

                                                                                                                                                                          orWhereExists: WhereExists<this>;

                                                                                                                                                                            property orWhereIn

                                                                                                                                                                            orWhereIn: WhereIn<this>;

                                                                                                                                                                              property orWhereNot

                                                                                                                                                                              orWhereNot: Where<this>;

                                                                                                                                                                                property orWhereNotBetween

                                                                                                                                                                                orWhereNotBetween: WhereBetween<this>;

                                                                                                                                                                                  property orWhereNotColumn

                                                                                                                                                                                  orWhereNotColumn: WhereColumn<this>;

                                                                                                                                                                                    property orWhereNotExists

                                                                                                                                                                                    orWhereNotExists: WhereExists<this>;

                                                                                                                                                                                      property orWhereNotIn

                                                                                                                                                                                      orWhereNotIn: WhereIn<this>;

                                                                                                                                                                                        property orWhereNotNull

                                                                                                                                                                                        orWhereNotNull: WhereNull<this>;

                                                                                                                                                                                          property orWhereNull

                                                                                                                                                                                          orWhereNull: WhereNull<this>;

                                                                                                                                                                                            property orWhereRaw

                                                                                                                                                                                            orWhereRaw: RawQueryFn<this>;

                                                                                                                                                                                              property rightJoin

                                                                                                                                                                                              rightJoin: Join<this>;

                                                                                                                                                                                                property rightOuterJoin

                                                                                                                                                                                                rightOuterJoin: Join<this>;

                                                                                                                                                                                                  property select

                                                                                                                                                                                                  select: DatabaseQueryBuilderSelect<this>;

                                                                                                                                                                                                    property subQueryAlias

                                                                                                                                                                                                    subQueryAlias?: string;

                                                                                                                                                                                                      property union

                                                                                                                                                                                                      union: Union<this>;

                                                                                                                                                                                                        property unionAll

                                                                                                                                                                                                        unionAll: UnionAll<this>;

                                                                                                                                                                                                          property where

                                                                                                                                                                                                          where: Where<this>;

                                                                                                                                                                                                            property whereBetween

                                                                                                                                                                                                            whereBetween: WhereBetween<this>;

                                                                                                                                                                                                              property whereColumn

                                                                                                                                                                                                              whereColumn: WhereColumn<this>;

                                                                                                                                                                                                                property whereExists

                                                                                                                                                                                                                whereExists: WhereExists<this>;

                                                                                                                                                                                                                  property whereIn

                                                                                                                                                                                                                  whereIn: WhereIn<this>;

                                                                                                                                                                                                                    property whereNot

                                                                                                                                                                                                                    whereNot: Where<this>;

                                                                                                                                                                                                                      property whereNotBetween

                                                                                                                                                                                                                      whereNotBetween: WhereBetween<this>;

                                                                                                                                                                                                                        property whereNotColumn

                                                                                                                                                                                                                        whereNotColumn: WhereColumn<this>;

                                                                                                                                                                                                                          property whereNotExists

                                                                                                                                                                                                                          whereNotExists: WhereExists<this>;

                                                                                                                                                                                                                            property whereNotIn

                                                                                                                                                                                                                            whereNotIn: WhereIn<this>;

                                                                                                                                                                                                                              property whereNotNull

                                                                                                                                                                                                                              whereNotNull: WhereNull<this>;

                                                                                                                                                                                                                                property whereNull

                                                                                                                                                                                                                                whereNull: WhereNull<this>;

                                                                                                                                                                                                                                  property whereRaw

                                                                                                                                                                                                                                  whereRaw: RawQueryFn<this>;

                                                                                                                                                                                                                                    property with

                                                                                                                                                                                                                                    with: With<this>;

                                                                                                                                                                                                                                      property withRecursive

                                                                                                                                                                                                                                      withRecursive: With<this>;

                                                                                                                                                                                                                                        method as

                                                                                                                                                                                                                                        as: (name: string) => this;

                                                                                                                                                                                                                                          method clearHaving

                                                                                                                                                                                                                                          clearHaving: () => this;

                                                                                                                                                                                                                                            method clearLimit

                                                                                                                                                                                                                                            clearLimit: () => this;

                                                                                                                                                                                                                                              method clearOffset

                                                                                                                                                                                                                                              clearOffset: () => this;

                                                                                                                                                                                                                                                method clearOrder

                                                                                                                                                                                                                                                clearOrder: () => this;

                                                                                                                                                                                                                                                  method clearSelect

                                                                                                                                                                                                                                                  clearSelect: () => this;

                                                                                                                                                                                                                                                    method clearWhere

                                                                                                                                                                                                                                                    clearWhere: () => this;

                                                                                                                                                                                                                                                      method forShare

                                                                                                                                                                                                                                                      forShare: (...tableNames: string[]) => this;

                                                                                                                                                                                                                                                        method forUpdate

                                                                                                                                                                                                                                                        forUpdate: (...tableNames: string[]) => this;

                                                                                                                                                                                                                                                          method if

                                                                                                                                                                                                                                                          if: (
                                                                                                                                                                                                                                                          condition: any,
                                                                                                                                                                                                                                                          matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                          noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                          ) => this;
                                                                                                                                                                                                                                                          • Executes the callback when condition is truthy

                                                                                                                                                                                                                                                          method limit

                                                                                                                                                                                                                                                          limit: (limit: number) => this;

                                                                                                                                                                                                                                                            method match

                                                                                                                                                                                                                                                            match: (
                                                                                                                                                                                                                                                            ...blocks: (
                                                                                                                                                                                                                                                            | [condition: any, callback: (query: this) => any]
                                                                                                                                                                                                                                                            | ((query: this) => any)
                                                                                                                                                                                                                                                            )[]
                                                                                                                                                                                                                                                            ) => this;
                                                                                                                                                                                                                                                            • Write blocks to match from

                                                                                                                                                                                                                                                            method noWait

                                                                                                                                                                                                                                                            noWait: () => this;

                                                                                                                                                                                                                                                              method offset

                                                                                                                                                                                                                                                              offset: (offset: number) => this;

                                                                                                                                                                                                                                                                method skipLocked

                                                                                                                                                                                                                                                                skipLocked: () => this;

                                                                                                                                                                                                                                                                  method unless

                                                                                                                                                                                                                                                                  unless: (
                                                                                                                                                                                                                                                                  condition: any,
                                                                                                                                                                                                                                                                  matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                                  noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                                  ) => this;
                                                                                                                                                                                                                                                                  • Executes the callback when condition is falsy

                                                                                                                                                                                                                                                                  method withSchema

                                                                                                                                                                                                                                                                  withSchema: (schema: string) => this;

                                                                                                                                                                                                                                                                    method wrapExisting

                                                                                                                                                                                                                                                                    wrapExisting: () => this;

                                                                                                                                                                                                                                                                      interface Counter

                                                                                                                                                                                                                                                                      interface Counter<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                      • Possible signatures for incrementing/decrementing values

                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                      (column: string, counter?: number): Builder;

                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                        (values: Dictionary<number, string>): Builder;

                                                                                                                                                                                                                                                                          interface DatabaseQueryBuilderContract

                                                                                                                                                                                                                                                                          interface DatabaseQueryBuilderContract<Result = Dictionary<any, string>>
                                                                                                                                                                                                                                                                          extends ChainableContract,
                                                                                                                                                                                                                                                                          ExcutableQueryBuilderContract<Result[]> {}
                                                                                                                                                                                                                                                                          • Database query builder exposes the API to construct SQL query using fluent chainable API

                                                                                                                                                                                                                                                                          property avg

                                                                                                                                                                                                                                                                          avg: Aggregate<this>;

                                                                                                                                                                                                                                                                            property avgDistinct

                                                                                                                                                                                                                                                                            avgDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                              property client

                                                                                                                                                                                                                                                                              client: QueryClientContract;

                                                                                                                                                                                                                                                                                property count

                                                                                                                                                                                                                                                                                count: Aggregate<this>;
                                                                                                                                                                                                                                                                                • Aggregates

                                                                                                                                                                                                                                                                                property countDistinct

                                                                                                                                                                                                                                                                                countDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                                  property decrement

                                                                                                                                                                                                                                                                                  decrement: Counter<this>;

                                                                                                                                                                                                                                                                                    property increment

                                                                                                                                                                                                                                                                                    increment: Counter<this>;

                                                                                                                                                                                                                                                                                      property max

                                                                                                                                                                                                                                                                                      max: Aggregate<this>;

                                                                                                                                                                                                                                                                                        property min

                                                                                                                                                                                                                                                                                        min: Aggregate<this>;

                                                                                                                                                                                                                                                                                          property returning

                                                                                                                                                                                                                                                                                          returning: Returning<this>;

                                                                                                                                                                                                                                                                                            property sum

                                                                                                                                                                                                                                                                                            sum: Aggregate<this>;

                                                                                                                                                                                                                                                                                              property sumDistinct

                                                                                                                                                                                                                                                                                              sumDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                                                property update

                                                                                                                                                                                                                                                                                                update: Update<this>;
                                                                                                                                                                                                                                                                                                • Mutations (update and increment can be one query aswell)

                                                                                                                                                                                                                                                                                                method clone

                                                                                                                                                                                                                                                                                                clone: <ClonedResult = Result>() => DatabaseQueryBuilderContract<ClonedResult>;
                                                                                                                                                                                                                                                                                                • Clone current query

                                                                                                                                                                                                                                                                                                method del

                                                                                                                                                                                                                                                                                                del: (returning?: OneOrMany<string>) => this;
                                                                                                                                                                                                                                                                                                • Perform delete operation

                                                                                                                                                                                                                                                                                                method delete

                                                                                                                                                                                                                                                                                                delete: (returning?: OneOrMany<string>) => this;

                                                                                                                                                                                                                                                                                                  method first

                                                                                                                                                                                                                                                                                                  first: () => Promise<Result | null>;
                                                                                                                                                                                                                                                                                                  • Execute and get first result

                                                                                                                                                                                                                                                                                                  method firstOrFail

                                                                                                                                                                                                                                                                                                  firstOrFail: () => Promise<Result>;
                                                                                                                                                                                                                                                                                                  • Execute and get first result or fail

                                                                                                                                                                                                                                                                                                  method forPage

                                                                                                                                                                                                                                                                                                  forPage: (page: number, perPage?: number) => this;
                                                                                                                                                                                                                                                                                                  • A shorthand to define limit and offset based upon the current page

                                                                                                                                                                                                                                                                                                  method ifDialect

                                                                                                                                                                                                                                                                                                  ifDialect: (
                                                                                                                                                                                                                                                                                                  dialect: DialectContract['name'] | DialectContract['name'][],
                                                                                                                                                                                                                                                                                                  matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                                                                  noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                                                                  ) => this;
                                                                                                                                                                                                                                                                                                  • Executes the callback when dialect matches one of the mentioned dialects

                                                                                                                                                                                                                                                                                                  method paginate

                                                                                                                                                                                                                                                                                                  paginate: (
                                                                                                                                                                                                                                                                                                  page: number,
                                                                                                                                                                                                                                                                                                  perPage?: number
                                                                                                                                                                                                                                                                                                  ) => Promise<SimplePaginatorContract<Result>>;
                                                                                                                                                                                                                                                                                                  • Execute query with pagination

                                                                                                                                                                                                                                                                                                  method unlessDialect

                                                                                                                                                                                                                                                                                                  unlessDialect: (
                                                                                                                                                                                                                                                                                                  dialect: DialectContract['name'] | DialectContract['name'][],
                                                                                                                                                                                                                                                                                                  matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                                                                  noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                                                                  ) => this;
                                                                                                                                                                                                                                                                                                  • Executes the callback when dialect matches doesn't all the mentioned dialects

                                                                                                                                                                                                                                                                                                  interface DatabaseQueryBuilderSelect

                                                                                                                                                                                                                                                                                                  interface DatabaseQueryBuilderSelect<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                  • Possible signatures for a select method on database query builder.

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (columns: Dictionary<string, string>): Builder;
                                                                                                                                                                                                                                                                                                  • Selecting columns as a dictionary with key as the alias and value is the original column.

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (columns: ValueWithSubQueries<string | number>[]): Builder;
                                                                                                                                                                                                                                                                                                  • An array of values with subqueries

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (...columns: ValueWithSubQueries<string | number>[]): Builder;
                                                                                                                                                                                                                                                                                                  • A spread of array arguments

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (column: '*'): Builder;
                                                                                                                                                                                                                                                                                                  • Wildcard selector.

                                                                                                                                                                                                                                                                                                  interface Distinct

                                                                                                                                                                                                                                                                                                  interface Distinct<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                  • Possible signatures for a distinct clause

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (columns: string[]): Builder;

                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                    (...columns: string[]): Builder;

                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                      (column: '*'): Builder;

                                                                                                                                                                                                                                                                                                        interface ExcutableQueryBuilderContract

                                                                                                                                                                                                                                                                                                        interface ExcutableQueryBuilderContract<Result> extends Promise<Result> {}
                                                                                                                                                                                                                                                                                                        • A executable query builder will always have these methods on it.

                                                                                                                                                                                                                                                                                                        method debug

                                                                                                                                                                                                                                                                                                        debug: (debug: boolean) => this;

                                                                                                                                                                                                                                                                                                          method exec

                                                                                                                                                                                                                                                                                                          exec: () => Promise<Result>;

                                                                                                                                                                                                                                                                                                            method reporterData

                                                                                                                                                                                                                                                                                                            reporterData: (data: any) => this;

                                                                                                                                                                                                                                                                                                              method timeout

                                                                                                                                                                                                                                                                                                              timeout: (time: number, options?: { cancel: boolean }) => this;

                                                                                                                                                                                                                                                                                                                method toQuery

                                                                                                                                                                                                                                                                                                                toQuery: () => string;

                                                                                                                                                                                                                                                                                                                  method toSQL

                                                                                                                                                                                                                                                                                                                  toSQL: () => any;

                                                                                                                                                                                                                                                                                                                    method useTransaction

                                                                                                                                                                                                                                                                                                                    useTransaction: (trx: TransactionClientContract) => this;

                                                                                                                                                                                                                                                                                                                      interface FromTable

                                                                                                                                                                                                                                                                                                                      interface FromTable<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                      • Possible signatures for defining table for a select query.

                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      table:
                                                                                                                                                                                                                                                                                                                      | string
                                                                                                                                                                                                                                                                                                                      | Dictionary<string, string>
                                                                                                                                                                                                                                                                                                                      | QueryCallback<Builder>
                                                                                                                                                                                                                                                                                                                      | ChainableContract
                                                                                                                                                                                                                                                                                                                      ): Builder;

                                                                                                                                                                                                                                                                                                                        interface GroupBy

                                                                                                                                                                                                                                                                                                                        interface GroupBy<Builder extends ChainableContract> extends Distinct<Builder> {}
                                                                                                                                                                                                                                                                                                                        • The signatures are same as the distinct method. For subqueries and raw queries, one must use groupByRaw.

                                                                                                                                                                                                                                                                                                                        interface Having

                                                                                                                                                                                                                                                                                                                        interface Having<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for having clause

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (callback: QueryCallback<Builder> | RawBuilderContract | RawQuery): Builder;
                                                                                                                                                                                                                                                                                                                        • A subquery callback

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        key: string | RawQuery,
                                                                                                                                                                                                                                                                                                                        operator: string,
                                                                                                                                                                                                                                                                                                                        value: StrictValues | ChainableContract | RawBuilderContract | RawQuery
                                                                                                                                                                                                                                                                                                                        ): Builder;
                                                                                                                                                                                                                                                                                                                        • Key operator and value. Value can be a subquery as well

                                                                                                                                                                                                                                                                                                                        interface HavingBetween

                                                                                                                                                                                                                                                                                                                        interface HavingBetween<Builder extends ChainableContract>
                                                                                                                                                                                                                                                                                                                        extends WhereBetween<Builder> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for having between

                                                                                                                                                                                                                                                                                                                        interface HavingExists

                                                                                                                                                                                                                                                                                                                        interface HavingExists<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for having exists clause

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (callback: QueryCallback<Builder> | ChainableContract): Builder;
                                                                                                                                                                                                                                                                                                                        • A query callback or a sub query

                                                                                                                                                                                                                                                                                                                        interface HavingIn

                                                                                                                                                                                                                                                                                                                        interface HavingIn<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for having in clause.

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        key: string | RawQuery,
                                                                                                                                                                                                                                                                                                                        value: (StrictValues | ChainableContract | RawBuilderContract | RawQuery)[]
                                                                                                                                                                                                                                                                                                                        ): Builder;
                                                                                                                                                                                                                                                                                                                        • Key and an array of literal values, raw queries or subqueries.

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (key: string | RawQuery, callback: QueryCallback<Builder>): Builder;
                                                                                                                                                                                                                                                                                                                        • Key, along with a query callback

                                                                                                                                                                                                                                                                                                                        interface HavingNull

                                                                                                                                                                                                                                                                                                                        interface HavingNull<Builder extends ChainableContract> extends WhereNull<Builder> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for having null clause

                                                                                                                                                                                                                                                                                                                        interface Insert

                                                                                                                                                                                                                                                                                                                        interface Insert<Builder extends InsertQueryBuilderContract> {}
                                                                                                                                                                                                                                                                                                                        • Possible signatures for an insert query

                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                        (values: Dictionary<any, string>): Builder;

                                                                                                                                                                                                                                                                                                                          interface InsertQueryBuilderContract

                                                                                                                                                                                                                                                                                                                          interface InsertQueryBuilderContract<Result = any>
                                                                                                                                                                                                                                                                                                                          extends ExcutableQueryBuilderContract<Result> {}
                                                                                                                                                                                                                                                                                                                          • Insert query builder to perform database inserts.

                                                                                                                                                                                                                                                                                                                          property client

                                                                                                                                                                                                                                                                                                                          client: QueryClientContract;

                                                                                                                                                                                                                                                                                                                            property insert

                                                                                                                                                                                                                                                                                                                            insert: Insert<this>;
                                                                                                                                                                                                                                                                                                                            • Inserting a single record.

                                                                                                                                                                                                                                                                                                                            property knexQuery

                                                                                                                                                                                                                                                                                                                            knexQuery: Knex.QueryBuilder;

                                                                                                                                                                                                                                                                                                                              property multiInsert

                                                                                                                                                                                                                                                                                                                              multiInsert: MultiInsert<this>;
                                                                                                                                                                                                                                                                                                                              • Inserting multiple columns at once

                                                                                                                                                                                                                                                                                                                              property returning

                                                                                                                                                                                                                                                                                                                              returning: Returning<this>;
                                                                                                                                                                                                                                                                                                                              • Define returning columns

                                                                                                                                                                                                                                                                                                                              method table

                                                                                                                                                                                                                                                                                                                              table: (table: string) => this;
                                                                                                                                                                                                                                                                                                                              • Table for the insert query

                                                                                                                                                                                                                                                                                                                              method withSchema

                                                                                                                                                                                                                                                                                                                              withSchema: (schema: string) => this;

                                                                                                                                                                                                                                                                                                                                interface Intersect

                                                                                                                                                                                                                                                                                                                                interface Intersect<Builder extends ChainableContract> extends Union<Builder> {}
                                                                                                                                                                                                                                                                                                                                • Same signature as union

                                                                                                                                                                                                                                                                                                                                interface Join

                                                                                                                                                                                                                                                                                                                                interface Join<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                • Possible signatures for join query

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (table: string, primaryColumn: string, secondaryColumn: string): Builder;
                                                                                                                                                                                                                                                                                                                                • Defining the join table with primary and secondary columns to match

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (table: string, primaryColumn: string, raw: RawQuery): Builder;
                                                                                                                                                                                                                                                                                                                                • Defining the join table with primary and secondary columns to match, where secondary column is output of a raw query

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                table: string,
                                                                                                                                                                                                                                                                                                                                primaryColumn: string,
                                                                                                                                                                                                                                                                                                                                operator: string,
                                                                                                                                                                                                                                                                                                                                secondaryColumn: string
                                                                                                                                                                                                                                                                                                                                ): Builder;
                                                                                                                                                                                                                                                                                                                                • Defining the join table with primary and secondary columns to match with a custom operator

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (table: string, callback: Knex.JoinCallback): Builder;
                                                                                                                                                                                                                                                                                                                                • Join with a callback. The callback receives an array of join class from knex directly.

                                                                                                                                                                                                                                                                                                                                interface MultiInsert

                                                                                                                                                                                                                                                                                                                                interface MultiInsert<Builder extends InsertQueryBuilderContract> {}
                                                                                                                                                                                                                                                                                                                                • Possible signatures for doing multiple inserts in a single query

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (values: Dictionary<any, string>[]): Builder;

                                                                                                                                                                                                                                                                                                                                  interface OrderBy

                                                                                                                                                                                                                                                                                                                                  interface OrderBy<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                  • Possible signatures for orderBy method.

                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  column: string | ChainableContract | RawBuilderContract | RawQuery,
                                                                                                                                                                                                                                                                                                                                  direction?: 'asc' | 'desc'
                                                                                                                                                                                                                                                                                                                                  ): Builder;
                                                                                                                                                                                                                                                                                                                                  • Order by a column and optional direction

                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                  (columns: string[]): Builder;
                                                                                                                                                                                                                                                                                                                                  • Order by multiple columns in default direction

                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  columns: {
                                                                                                                                                                                                                                                                                                                                  column: string | ChainableContract | RawBuilderContract | RawQuery;
                                                                                                                                                                                                                                                                                                                                  order?: 'asc' | 'desc';
                                                                                                                                                                                                                                                                                                                                  }[]
                                                                                                                                                                                                                                                                                                                                  ): Builder;
                                                                                                                                                                                                                                                                                                                                  • Order by multiple columns and custom direction for each of them

                                                                                                                                                                                                                                                                                                                                  interface RawBuilderContract

                                                                                                                                                                                                                                                                                                                                  interface RawBuilderContract {}
                                                                                                                                                                                                                                                                                                                                  • Static raw builder

                                                                                                                                                                                                                                                                                                                                  method toKnex

                                                                                                                                                                                                                                                                                                                                  toKnex: (client: any) => any;

                                                                                                                                                                                                                                                                                                                                    method wrap

                                                                                                                                                                                                                                                                                                                                    wrap: (before: string, after: string) => this;

                                                                                                                                                                                                                                                                                                                                      interface RawQueryBuilderContract

                                                                                                                                                                                                                                                                                                                                      interface RawQueryBuilderContract<Result = any>
                                                                                                                                                                                                                                                                                                                                      extends ExcutableQueryBuilderContract<Result> {}
                                                                                                                                                                                                                                                                                                                                      • Shape of the raw query that can also be passed as a value to other queries

                                                                                                                                                                                                                                                                                                                                      property client

                                                                                                                                                                                                                                                                                                                                      client: QueryClientContract;

                                                                                                                                                                                                                                                                                                                                        property knexQuery

                                                                                                                                                                                                                                                                                                                                        knexQuery: Knex.Raw;

                                                                                                                                                                                                                                                                                                                                          method wrap

                                                                                                                                                                                                                                                                                                                                          wrap: (before: string, after: string) => this;

                                                                                                                                                                                                                                                                                                                                            interface RawQueryFn

                                                                                                                                                                                                                                                                                                                                            interface RawQueryFn<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                            • A builder method to allow raw queries. However, the return type is the instance of current query builder. This is used for .{verb}Raw methods.

                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                            (sql: string | RawQuery): Builder;

                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                              (sql: string, bindings: RawQueryBindings): Builder;

                                                                                                                                                                                                                                                                                                                                                interface ReferenceBuilderContract

                                                                                                                                                                                                                                                                                                                                                interface ReferenceBuilderContract {}
                                                                                                                                                                                                                                                                                                                                                • Reference builder

                                                                                                                                                                                                                                                                                                                                                method as

                                                                                                                                                                                                                                                                                                                                                as: (name: string) => this;

                                                                                                                                                                                                                                                                                                                                                  method toKnex

                                                                                                                                                                                                                                                                                                                                                  toKnex: (client: any) => any;

                                                                                                                                                                                                                                                                                                                                                    method withSchema

                                                                                                                                                                                                                                                                                                                                                    withSchema: (name: string) => this;

                                                                                                                                                                                                                                                                                                                                                      interface Returning

                                                                                                                                                                                                                                                                                                                                                      interface Returning<Builder> {}
                                                                                                                                                                                                                                                                                                                                                      • Possible signatures for the returning method.

                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                      (column: OneOrMany<string>): Builder;

                                                                                                                                                                                                                                                                                                                                                        interface SimplePaginatorContract

                                                                                                                                                                                                                                                                                                                                                        interface SimplePaginatorContract<Result> extends Array<Result> {}
                                                                                                                                                                                                                                                                                                                                                        • Shape of the simple paginator that works with offset and limit

                                                                                                                                                                                                                                                                                                                                                        property currentPage

                                                                                                                                                                                                                                                                                                                                                        readonly currentPage: number;

                                                                                                                                                                                                                                                                                                                                                          property firstPage

                                                                                                                                                                                                                                                                                                                                                          readonly firstPage: number;

                                                                                                                                                                                                                                                                                                                                                            property hasMorePages

                                                                                                                                                                                                                                                                                                                                                            readonly hasMorePages: boolean;

                                                                                                                                                                                                                                                                                                                                                              property hasPages

                                                                                                                                                                                                                                                                                                                                                              readonly hasPages: boolean;

                                                                                                                                                                                                                                                                                                                                                                property hasTotal

                                                                                                                                                                                                                                                                                                                                                                readonly hasTotal: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property isEmpty

                                                                                                                                                                                                                                                                                                                                                                  readonly isEmpty: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property lastPage

                                                                                                                                                                                                                                                                                                                                                                    readonly lastPage: number;

                                                                                                                                                                                                                                                                                                                                                                      property namingStrategy

                                                                                                                                                                                                                                                                                                                                                                      namingStrategy: {
                                                                                                                                                                                                                                                                                                                                                                      paginationMetaKeys(): SimplePaginatorMetaKeys;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        property perPage

                                                                                                                                                                                                                                                                                                                                                                        readonly perPage: number;

                                                                                                                                                                                                                                                                                                                                                                          property total

                                                                                                                                                                                                                                                                                                                                                                          readonly total: number;

                                                                                                                                                                                                                                                                                                                                                                            method all

                                                                                                                                                                                                                                                                                                                                                                            all: () => Result[];

                                                                                                                                                                                                                                                                                                                                                                              method baseUrl

                                                                                                                                                                                                                                                                                                                                                                              baseUrl: (url: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                method getMeta

                                                                                                                                                                                                                                                                                                                                                                                getMeta: () => any;

                                                                                                                                                                                                                                                                                                                                                                                  method getNextPageUrl

                                                                                                                                                                                                                                                                                                                                                                                  getNextPageUrl: () => string | null;

                                                                                                                                                                                                                                                                                                                                                                                    method getPreviousPageUrl

                                                                                                                                                                                                                                                                                                                                                                                    getPreviousPageUrl: () => string | null;

                                                                                                                                                                                                                                                                                                                                                                                      method getUrl

                                                                                                                                                                                                                                                                                                                                                                                      getUrl: (page: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                        method getUrlsForRange

                                                                                                                                                                                                                                                                                                                                                                                        getUrlsForRange: (
                                                                                                                                                                                                                                                                                                                                                                                        start: number,
                                                                                                                                                                                                                                                                                                                                                                                        end: number
                                                                                                                                                                                                                                                                                                                                                                                        ) => { url: string; page: number; isActive: boolean }[];

                                                                                                                                                                                                                                                                                                                                                                                          method queryString

                                                                                                                                                                                                                                                                                                                                                                                          queryString: (values: { [key: string]: any }) => this;

                                                                                                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                                                                                                            toJSON: () => { meta: any; data: Result[] };

                                                                                                                                                                                                                                                                                                                                                                                              interface Union

                                                                                                                                                                                                                                                                                                                                                                                              interface Union<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                              • Possible signatures for a union clause

                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                              (callback: OneOrMany<QueryCallback<Builder>>, wrap?: boolean): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                (subquery: OneOrMany<ChainableContract | RawQuery>, wrap?: boolean): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                  interface UnionAll

                                                                                                                                                                                                                                                                                                                                                                                                  interface UnionAll<Builder extends ChainableContract> extends Union<Builder> {}
                                                                                                                                                                                                                                                                                                                                                                                                  • Same signature as union

                                                                                                                                                                                                                                                                                                                                                                                                  interface Update

                                                                                                                                                                                                                                                                                                                                                                                                  interface Update<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                  • Possible signatures for performing an update

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (values: Dictionary<any, string>, returning?: OneOrMany<string>): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                  • Accepts an array of object of named key/value pair and returns an array of Generic return columns.

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (column: string, value: any, returning?: OneOrMany<string>): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                  • Accepts a key-value pair to update.

                                                                                                                                                                                                                                                                                                                                                                                                  interface Where

                                                                                                                                                                                                                                                                                                                                                                                                  interface Where<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                  • Possible signatures for adding a where clause

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (callback: QueryCallback<Builder>): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                  • Callback for wrapped clauses

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (clause: Dictionary<any, string>): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                  • Passing an object of named key-value pair

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (key: string | RawQuery, value: StrictValues | ChainableContract): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                  • Key-value pair. The value can also be a subquery

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                  key: string | RawQuery,
                                                                                                                                                                                                                                                                                                                                                                                                  operator: string,
                                                                                                                                                                                                                                                                                                                                                                                                  value: StrictValues | ChainableContract
                                                                                                                                                                                                                                                                                                                                                                                                  ): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                    interface WhereBetween

                                                                                                                                                                                                                                                                                                                                                                                                    interface WhereBetween<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                    • Possibles signatures for adding a where between clause

                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                    key: string | RawQuery,
                                                                                                                                                                                                                                                                                                                                                                                                    value: [StrictValues | ChainableContract, StrictValues | ChainableContract]
                                                                                                                                                                                                                                                                                                                                                                                                    ): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                    • Accept any string as a key for supporting prefix columns

                                                                                                                                                                                                                                                                                                                                                                                                    interface WhereColumn

                                                                                                                                                                                                                                                                                                                                                                                                    interface WhereColumn<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                    • Possible signatures for adding a where column clause

                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                    (column: string | RawQuery, comparisonColumn: string): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                    • Key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                    (column: string | RawQuery, operator: string, comparisonColumn: string): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                      interface WhereExists

                                                                                                                                                                                                                                                                                                                                                                                                      interface WhereExists<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                      • Possibles signatures for adding a where exists clause

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                      callback:
                                                                                                                                                                                                                                                                                                                                                                                                      | QueryCallback<Builder>
                                                                                                                                                                                                                                                                                                                                                                                                      | ChainableContract
                                                                                                                                                                                                                                                                                                                                                                                                      | RawBuilderContract
                                                                                                                                                                                                                                                                                                                                                                                                      | RawQuery
                                                                                                                                                                                                                                                                                                                                                                                                      ): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                        interface WhereIn

                                                                                                                                                                                                                                                                                                                                                                                                        interface WhereIn<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                        • Possible signatures for adding where in clause.

                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                        (K: string | RawQuery, value: StrictValues[]): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                        • Column name and array of values

                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                        (K: string[], value: StrictValues[][]): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                        • Column names and array of values as an 2d array

                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                        k: string | RawQuery,
                                                                                                                                                                                                                                                                                                                                                                                                        subquery:
                                                                                                                                                                                                                                                                                                                                                                                                        | ChainableContract
                                                                                                                                                                                                                                                                                                                                                                                                        | QueryCallback<Builder>
                                                                                                                                                                                                                                                                                                                                                                                                        | RawBuilderContract
                                                                                                                                                                                                                                                                                                                                                                                                        | RawQuery
                                                                                                                                                                                                                                                                                                                                                                                                        ): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                        • Column name with a subquery for a callback that yields an array of results

                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                        k: string[],
                                                                                                                                                                                                                                                                                                                                                                                                        subquery: ChainableContract | RawBuilderContract | RawQuery
                                                                                                                                                                                                                                                                                                                                                                                                        ): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                        • Column names along with a subquery that yields an array

                                                                                                                                                                                                                                                                                                                                                                                                        interface WhereNull

                                                                                                                                                                                                                                                                                                                                                                                                        interface WhereNull<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                        • Possible signatures for adding whereNull clause.

                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                        (key: string | RawQuery): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                          interface With

                                                                                                                                                                                                                                                                                                                                                                                                          interface With<Builder extends ChainableContract> {}
                                                                                                                                                                                                                                                                                                                                                                                                          • Possible signatures of with CTE

                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                          alias: string,
                                                                                                                                                                                                                                                                                                                                                                                                          query: RawQuery | ChainableContract | QueryCallback<Builder>
                                                                                                                                                                                                                                                                                                                                                                                                          ): Builder;

                                                                                                                                                                                                                                                                                                                                                                                                            type DBQueryCallback

                                                                                                                                                                                                                                                                                                                                                                                                            type DBQueryCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                            userFn: QueryCallback<ChainableContract>,
                                                                                                                                                                                                                                                                                                                                                                                                            keysResolver?: (columnName: string) => string
                                                                                                                                                                                                                                                                                                                                                                                                            ) => (builder: Knex.QueryBuilder) => void;
                                                                                                                                                                                                                                                                                                                                                                                                            • Shape of the function accepted by the chainable query builder to pass lucid query builder to wrapped callbacks like .where(function () {}).

                                                                                                                                                                                                                                                                                                                                                                                                              - This method will accept the wrapped callback - Return a new method, that is accepted by Knex. - When knex calls that method, this method will invoke the user wrapped callback, but instead of passing the knex query builder, it will pass the appropriate lucid query builder.

                                                                                                                                                                                                                                                                                                                                                                                                            type Dictionary

                                                                                                                                                                                                                                                                                                                                                                                                            type Dictionary<T, K extends string | number = string> = {
                                                                                                                                                                                                                                                                                                                                                                                                            [key in K]: T;
                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                            • Extracted from ts-essentials

                                                                                                                                                                                                                                                                                                                                                                                                            type OneOrMany

                                                                                                                                                                                                                                                                                                                                                                                                            type OneOrMany<T> = T | T[];
                                                                                                                                                                                                                                                                                                                                                                                                            • Get one or many of a generic

                                                                                                                                                                                                                                                                                                                                                                                                            type QueryCallback

                                                                                                                                                                                                                                                                                                                                                                                                            type QueryCallback<Builder> = (builder: Builder) => void;
                                                                                                                                                                                                                                                                                                                                                                                                            • Query callback is used to write wrapped queries. We get rid of this from knex, since it makes everything confusing.

                                                                                                                                                                                                                                                                                                                                                                                                            type RawQuery

                                                                                                                                                                                                                                                                                                                                                                                                            type RawQuery =
                                                                                                                                                                                                                                                                                                                                                                                                            | RawBuilderContract
                                                                                                                                                                                                                                                                                                                                                                                                            | RawQueryBuilderContract
                                                                                                                                                                                                                                                                                                                                                                                                            | Knex.Raw
                                                                                                                                                                                                                                                                                                                                                                                                            | Knex.RawQueryBuilder;
                                                                                                                                                                                                                                                                                                                                                                                                            • Acceptable raw queries

                                                                                                                                                                                                                                                                                                                                                                                                            type RawQueryBindings

                                                                                                                                                                                                                                                                                                                                                                                                            type RawQueryBindings =
                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: StrictValues;
                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                            | StrictValues[];
                                                                                                                                                                                                                                                                                                                                                                                                            • Shape of raw query bindings

                                                                                                                                                                                                                                                                                                                                                                                                            type SimplePaginatorMetaKeys

                                                                                                                                                                                                                                                                                                                                                                                                            type SimplePaginatorMetaKeys = {
                                                                                                                                                                                                                                                                                                                                                                                                            total: string;
                                                                                                                                                                                                                                                                                                                                                                                                            perPage: string;
                                                                                                                                                                                                                                                                                                                                                                                                            currentPage: string;
                                                                                                                                                                                                                                                                                                                                                                                                            lastPage: string;
                                                                                                                                                                                                                                                                                                                                                                                                            firstPage: string;
                                                                                                                                                                                                                                                                                                                                                                                                            firstPageUrl: string;
                                                                                                                                                                                                                                                                                                                                                                                                            lastPageUrl: string;
                                                                                                                                                                                                                                                                                                                                                                                                            nextPageUrl: string;
                                                                                                                                                                                                                                                                                                                                                                                                            previousPageUrl: string;
                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                            • The keys for the simple paginator meta data

                                                                                                                                                                                                                                                                                                                                                                                                            type StrictValues

                                                                                                                                                                                                                                                                                                                                                                                                            type StrictValues =
                                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                                                                                                                                            | Date
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<string>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<number>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<Date>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<boolean>
                                                                                                                                                                                                                                                                                                                                                                                                            | Buffer
                                                                                                                                                                                                                                                                                                                                                                                                            | RawQuery
                                                                                                                                                                                                                                                                                                                                                                                                            | ReferenceBuilderContract;
                                                                                                                                                                                                                                                                                                                                                                                                            • A known set of values allowed when defining values for different clauses

                                                                                                                                                                                                                                                                                                                                                                                                            type StrictValuesWithoutRaw

                                                                                                                                                                                                                                                                                                                                                                                                            type StrictValuesWithoutRaw = Exclude<StrictValues, RawQuery>;
                                                                                                                                                                                                                                                                                                                                                                                                            • Strict set of allowed values except the raw queries

                                                                                                                                                                                                                                                                                                                                                                                                            type ValueWithSubQueries

                                                                                                                                                                                                                                                                                                                                                                                                            type ValueWithSubQueries<T> = T | ChainableContract | RawQuery;
                                                                                                                                                                                                                                                                                                                                                                                                            • Allowing a generic value along with raw query instance or a subquery instance

                                                                                                                                                                                                                                                                                                                                                                                                            namespace @ioc:Adonis/Lucid/Factory

                                                                                                                                                                                                                                                                                                                                                                                                            module '@ioc:Adonis/Lucid/Factory' {}

                                                                                                                                                                                                                                                                                                                                                                                                              variable Factory

                                                                                                                                                                                                                                                                                                                                                                                                              const Factory: FactoryManagerContract;

                                                                                                                                                                                                                                                                                                                                                                                                                interface FactoryBuilderContract

                                                                                                                                                                                                                                                                                                                                                                                                                interface FactoryBuilderContract<
                                                                                                                                                                                                                                                                                                                                                                                                                FactoryModel extends FactoryModelContract<LucidModel>
                                                                                                                                                                                                                                                                                                                                                                                                                > {}
                                                                                                                                                                                                                                                                                                                                                                                                                • Factory builder uses the factory model to create/make instances of lucid models

                                                                                                                                                                                                                                                                                                                                                                                                                method apply

                                                                                                                                                                                                                                                                                                                                                                                                                apply: <K extends keyof FactoryModel['states']>(...states: K[]) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Apply pre-defined state

                                                                                                                                                                                                                                                                                                                                                                                                                method client

                                                                                                                                                                                                                                                                                                                                                                                                                client: (client: QueryClientContract) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Define custom query client

                                                                                                                                                                                                                                                                                                                                                                                                                method connection

                                                                                                                                                                                                                                                                                                                                                                                                                connection: (connection: string) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Define custom database connection

                                                                                                                                                                                                                                                                                                                                                                                                                method create

                                                                                                                                                                                                                                                                                                                                                                                                                create: (
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Create and persist model instance

                                                                                                                                                                                                                                                                                                                                                                                                                method createMany

                                                                                                                                                                                                                                                                                                                                                                                                                createMany: (
                                                                                                                                                                                                                                                                                                                                                                                                                count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Create and persist more than one model instance

                                                                                                                                                                                                                                                                                                                                                                                                                method make

                                                                                                                                                                                                                                                                                                                                                                                                                make: (
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Make model instance without persitance. The make method doesn't process relationships

                                                                                                                                                                                                                                                                                                                                                                                                                method makeMany

                                                                                                                                                                                                                                                                                                                                                                                                                makeMany: (
                                                                                                                                                                                                                                                                                                                                                                                                                count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Make model instance without persitance. The makeMany method doesn't process relationships

                                                                                                                                                                                                                                                                                                                                                                                                                method makeStubbed

                                                                                                                                                                                                                                                                                                                                                                                                                makeStubbed: (
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Create model instance and stub out the persistance mechanism

                                                                                                                                                                                                                                                                                                                                                                                                                method makeStubbedMany

                                                                                                                                                                                                                                                                                                                                                                                                                makeStubbedMany: (
                                                                                                                                                                                                                                                                                                                                                                                                                count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                model: InstanceType<FactoryModel['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<FactoryModel['model']>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Create one or more model instances and stub out the persistance mechanism.

                                                                                                                                                                                                                                                                                                                                                                                                                method merge

                                                                                                                                                                                                                                                                                                                                                                                                                merge: (attributes: OneOrMany<ExtractFactoryAttributes<FactoryModel>>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Merge custom set of attributes. They are passed to the merge method of the model factory

                                                                                                                                                                                                                                                                                                                                                                                                                  For createMany and makeMany, you can pass an array of attributes mapped according to the array index.

                                                                                                                                                                                                                                                                                                                                                                                                                method useCtx

                                                                                                                                                                                                                                                                                                                                                                                                                useCtx: (ctx: FactoryContextContract) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Define custom runtime context. This method is usually called by the relationships to ensure a single context is used by the parent and relationship factories.

                                                                                                                                                                                                                                                                                                                                                                                                                  Do not define a custom context, unless you know what you are really doing.

                                                                                                                                                                                                                                                                                                                                                                                                                method with

                                                                                                                                                                                                                                                                                                                                                                                                                with: <K extends keyof FactoryModel['relations']>(
                                                                                                                                                                                                                                                                                                                                                                                                                relation: K,
                                                                                                                                                                                                                                                                                                                                                                                                                count?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                factory: FactoryModel['relations'][K] extends () => FactoryBuilderContract<any>
                                                                                                                                                                                                                                                                                                                                                                                                                ? ReturnType<FactoryModel['relations'][K]>
                                                                                                                                                                                                                                                                                                                                                                                                                : never
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                • Create/make relationships for explicitly defined related factories

                                                                                                                                                                                                                                                                                                                                                                                                                interface FactoryBuilderQueryContract

                                                                                                                                                                                                                                                                                                                                                                                                                interface FactoryBuilderQueryContract<
                                                                                                                                                                                                                                                                                                                                                                                                                FactoryModel extends FactoryModelContract<LucidModel>
                                                                                                                                                                                                                                                                                                                                                                                                                > extends FactoryBuilderContract<FactoryModel> {}
                                                                                                                                                                                                                                                                                                                                                                                                                • Query contract that initiates the factory builder. Since the factory builder API surface is small, we also proxy all of it's methods for a nicer DX

                                                                                                                                                                                                                                                                                                                                                                                                                method query

                                                                                                                                                                                                                                                                                                                                                                                                                query: (options?: ModelAdapterOptions) => FactoryBuilderContract<FactoryModel>;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface FactoryContextContract

                                                                                                                                                                                                                                                                                                                                                                                                                  interface FactoryContextContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • The runtime context of the factory builder. A new state is constructed for each create/make operation and passed down to relationships as well.

                                                                                                                                                                                                                                                                                                                                                                                                                  property $trx

                                                                                                                                                                                                                                                                                                                                                                                                                  $trx: TransactionClientContract | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    property faker

                                                                                                                                                                                                                                                                                                                                                                                                                    faker: typeof faker;

                                                                                                                                                                                                                                                                                                                                                                                                                      property isStubbed

                                                                                                                                                                                                                                                                                                                                                                                                                      isStubbed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryManagerContract

                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryManagerContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                        • Factory manager to define new factories

                                                                                                                                                                                                                                                                                                                                                                                                                        method define

                                                                                                                                                                                                                                                                                                                                                                                                                        define: <Model extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                        model: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                        callback: DefineCallback<Model>
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => FactoryModelContract<Model>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Define a custom factory

                                                                                                                                                                                                                                                                                                                                                                                                                        method stubId

                                                                                                                                                                                                                                                                                                                                                                                                                        stubId: (callback: StubIdCallback) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Define a custom callback to generate stub ids

                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryModelContract

                                                                                                                                                                                                                                                                                                                                                                                                                        interface FactoryModelContract<Model extends LucidModel> {}
                                                                                                                                                                                                                                                                                                                                                                                                                        • Factory model exposes the API to defined a model factory with states and relationships

                                                                                                                                                                                                                                                                                                                                                                                                                        property model

                                                                                                                                                                                                                                                                                                                                                                                                                        model: Model;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Reference to the underlying lucid model used by the factory model

                                                                                                                                                                                                                                                                                                                                                                                                                        property relations

                                                                                                                                                                                                                                                                                                                                                                                                                        relations: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                          property states

                                                                                                                                                                                                                                                                                                                                                                                                                          states: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Mainly for types support. Not used at runtime to derive any logic. Sorry, at times have to hack into typescript to get the desired output. :)

                                                                                                                                                                                                                                                                                                                                                                                                                          method after

                                                                                                                                                                                                                                                                                                                                                                                                                          after: (event: EventsList, handler: HooksHandler<this>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Define after hooks.

                                                                                                                                                                                                                                                                                                                                                                                                                          method before

                                                                                                                                                                                                                                                                                                                                                                                                                          before: (
                                                                                                                                                                                                                                                                                                                                                                                                                          event: Exclude<EventsList, 'make'>,
                                                                                                                                                                                                                                                                                                                                                                                                                          handler: HooksHandler<this>
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Define before hooks. Only create event is invoked during the before lifecycle

                                                                                                                                                                                                                                                                                                                                                                                                                          method build

                                                                                                                                                                                                                                                                                                                                                                                                                          build: () => FactoryBuilderQueryContract<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Build model factory. This method returns the factory builder, which can be used to execute model queries

                                                                                                                                                                                                                                                                                                                                                                                                                          method merge

                                                                                                                                                                                                                                                                                                                                                                                                                          merge: (callback: MergeCallback<this>) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                            method newUp

                                                                                                                                                                                                                                                                                                                                                                                                                            newUp: (callback: NewUpCallback<this>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Optionally define a custom method to instantiate the model instance

                                                                                                                                                                                                                                                                                                                                                                                                                            method relation

                                                                                                                                                                                                                                                                                                                                                                                                                            relation: <K extends ExtractModelRelations<InstanceType<Model>>, Relation>(
                                                                                                                                                                                                                                                                                                                                                                                                                            relation: K,
                                                                                                                                                                                                                                                                                                                                                                                                                            callback: Relation
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this & { relations: { [P in K]: Relation } };
                                                                                                                                                                                                                                                                                                                                                                                                                            • Define a relationship on another factory

                                                                                                                                                                                                                                                                                                                                                                                                                            method state

                                                                                                                                                                                                                                                                                                                                                                                                                            state: <K extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                            state: K,
                                                                                                                                                                                                                                                                                                                                                                                                                            callback: StateCallback<InstanceType<Model>>
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this & { states: { [P in K]: StateCallback<InstanceType<Model>> } };
                                                                                                                                                                                                                                                                                                                                                                                                                            • Define custom state for the factory. When executing the factory, you can apply the pre-defined states

                                                                                                                                                                                                                                                                                                                                                                                                                            interface FactoryRelationContract

                                                                                                                                                                                                                                                                                                                                                                                                                            interface FactoryRelationContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                            • Shape of the factory relationships. To keep relationships slim, we will have a common interface for relationships vs fine tuning API for each type of relationship

                                                                                                                                                                                                                                                                                                                                                                                                                            property relation

                                                                                                                                                                                                                                                                                                                                                                                                                            relation: RelationshipsContract;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Reference to the Lucid model relationship

                                                                                                                                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                                                                                                                                            create: (
                                                                                                                                                                                                                                                                                                                                                                                                                            parent: LucidRow,
                                                                                                                                                                                                                                                                                                                                                                                                                            callback?: RelationCallback,
                                                                                                                                                                                                                                                                                                                                                                                                                            count?: number
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Create and persist

                                                                                                                                                                                                                                                                                                                                                                                                                            method make

                                                                                                                                                                                                                                                                                                                                                                                                                            make: (
                                                                                                                                                                                                                                                                                                                                                                                                                            parent: LucidRow,
                                                                                                                                                                                                                                                                                                                                                                                                                            callback?: RelationCallback,
                                                                                                                                                                                                                                                                                                                                                                                                                            count?: number
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Create and stub

                                                                                                                                                                                                                                                                                                                                                                                                                            method useCtx

                                                                                                                                                                                                                                                                                                                                                                                                                            useCtx: (ctx: FactoryContextContract) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Pass context to the relationship. Must be done everytime, so that relationships uses the same transaction as the parent model

                                                                                                                                                                                                                                                                                                                                                                                                                            type DefineCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type DefineCallback<Model extends LucidModel> = (
                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                            ) =>
                                                                                                                                                                                                                                                                                                                                                                                                                            | Promise<Partial<ModelAttributes<InstanceType<Model>>>>
                                                                                                                                                                                                                                                                                                                                                                                                                            | Partial<ModelAttributes<InstanceType<Model>>>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Function to return the model attributes.

                                                                                                                                                                                                                                                                                                                                                                                                                            type EventsList

                                                                                                                                                                                                                                                                                                                                                                                                                            type EventsList = 'makeStubbed' | 'create' | 'make';
                                                                                                                                                                                                                                                                                                                                                                                                                            • List of events for which a factory will trigger hooks

                                                                                                                                                                                                                                                                                                                                                                                                                            type ExtractFactoryAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                            type ExtractFactoryAttributes<T extends FactoryModelContract<LucidModel>> = Partial<
                                                                                                                                                                                                                                                                                                                                                                                                                            ModelAttributes<InstanceType<T['model']>>
                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Extracts the attributes accepted by the lucid model set on a factory

                                                                                                                                                                                                                                                                                                                                                                                                                            type HooksHandler

                                                                                                                                                                                                                                                                                                                                                                                                                            type HooksHandler<Model extends FactoryModelContract<LucidModel>> = (
                                                                                                                                                                                                                                                                                                                                                                                                                            factory: FactoryBuilderContract<Model>,
                                                                                                                                                                                                                                                                                                                                                                                                                            model: InstanceType<Model['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Shape of hooks handler

                                                                                                                                                                                                                                                                                                                                                                                                                            type MergeCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type MergeCallback<T extends FactoryModelContract<LucidModel>> = (
                                                                                                                                                                                                                                                                                                                                                                                                                            model: InstanceType<T['model']>,
                                                                                                                                                                                                                                                                                                                                                                                                                            attributes: ExtractFactoryAttributes<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Function to merge attributes defined during runtime

                                                                                                                                                                                                                                                                                                                                                                                                                            type NewUpCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type NewUpCallback<T extends FactoryModelContract<LucidModel>> = (
                                                                                                                                                                                                                                                                                                                                                                                                                            attributes: ExtractFactoryAttributes<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => InstanceType<T['model']>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Function to initiate a model instance. It will receive the attributes returned by the define method

                                                                                                                                                                                                                                                                                                                                                                                                                            type RelationCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type RelationCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                            factory: FactoryBuilderContract<FactoryModelContract<LucidModel>>
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Callback accepted by the with method and relationships create and make methods

                                                                                                                                                                                                                                                                                                                                                                                                                            type StateCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type StateCallback<Model extends LucidRow> = (
                                                                                                                                                                                                                                                                                                                                                                                                                            model: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: FactoryContextContract
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => any | Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Callback to define a new model state

                                                                                                                                                                                                                                                                                                                                                                                                                            type StubIdCallback

                                                                                                                                                                                                                                                                                                                                                                                                                            type StubIdCallback = (counter: number, model: LucidRow) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Function to generate custom stub ids

                                                                                                                                                                                                                                                                                                                                                                                                                            namespace @ioc:Adonis/Lucid/Migrator

                                                                                                                                                                                                                                                                                                                                                                                                                            module '@ioc:Adonis/Lucid/Migrator' {}

                                                                                                                                                                                                                                                                                                                                                                                                                              variable Migrator

                                                                                                                                                                                                                                                                                                                                                                                                                              const Migrator: new (
                                                                                                                                                                                                                                                                                                                                                                                                                              db: DatabaseContract,
                                                                                                                                                                                                                                                                                                                                                                                                                              app: any,
                                                                                                                                                                                                                                                                                                                                                                                                                              options: MigratorOptions
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => MigratorContract;
                                                                                                                                                                                                                                                                                                                                                                                                                              • Migrator class constructor

                                                                                                                                                                                                                                                                                                                                                                                                                              interface MigratorContract

                                                                                                                                                                                                                                                                                                                                                                                                                              interface MigratorContract extends EventEmitter {}
                                                                                                                                                                                                                                                                                                                                                                                                                              • Shape of the migrator

                                                                                                                                                                                                                                                                                                                                                                                                                              property direction

                                                                                                                                                                                                                                                                                                                                                                                                                              direction: 'up' | 'down';

                                                                                                                                                                                                                                                                                                                                                                                                                                property dryRun

                                                                                                                                                                                                                                                                                                                                                                                                                                dryRun: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property error

                                                                                                                                                                                                                                                                                                                                                                                                                                  error: null | Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property migratedFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                    migratedFiles: {
                                                                                                                                                                                                                                                                                                                                                                                                                                    [file: string]: MigratedFileNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                      property status

                                                                                                                                                                                                                                                                                                                                                                                                                                      status: 'completed' | 'skipped' | 'pending' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                                                                                                                                                        close: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getList

                                                                                                                                                                                                                                                                                                                                                                                                                                          getList: () => Promise<MigrationListNode[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method on

                                                                                                                                                                                                                                                                                                                                                                                                                                            on: {
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'start', callback: () => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'end', callback: () => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'acquire:lock', callback: () => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'release:lock', callback: () => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'create:schema:table', callback: () => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'migration:start', callback: (file: MigratedFileNode) => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                            event: 'migration:completed',
                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: (file: MigratedFileNode) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                            ): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: 'migration:error', callback: (file: MigratedFileNode) => void): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                              method run

                                                                                                                                                                                                                                                                                                                                                                                                                                              run: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigratedFileNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigratedFileNode = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                status: 'completed' | 'error' | 'pending';
                                                                                                                                                                                                                                                                                                                                                                                                                                                queries: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                file: FileNode<unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                batch: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Shape of migrated file within migrator

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigrationListNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigrationListNode = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                status: 'pending' | 'migrated' | 'corrupt';
                                                                                                                                                                                                                                                                                                                                                                                                                                                batch?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                migrationTime?: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Shape of migrated file within migrator

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigratorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MigratorOptions =
                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                direction: 'up';
                                                                                                                                                                                                                                                                                                                                                                                                                                                connectionName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                dryRun?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                direction: 'down';
                                                                                                                                                                                                                                                                                                                                                                                                                                                batch?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                connectionName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                dryRun?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Options accepted by migrator constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace @ioc:Adonis/Lucid/Orm

                                                                                                                                                                                                                                                                                                                                                                                                                                                module '@ioc:Adonis/Lucid/Orm' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AdapterContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AdapterContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Every adapter must adhere to the Adapter contract

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                  delete: (instance: LucidRow) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delete model instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method insert

                                                                                                                                                                                                                                                                                                                                                                                                                                                  insert: (instance: LucidRow, attributes: ModelObject) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Perform insert

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method modelClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                  modelClient: (instance: LucidRow) => QueryClientContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns query client for a model instance by inspecting it's options

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method modelConstructorClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                  modelConstructorClient: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  modelConstructor: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => QueryClientContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns query client for a model constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method query

                                                                                                                                                                                                                                                                                                                                                                                                                                                  query: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  modelConstructor: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ModelQueryBuilderContract<LucidModel, LucidRow>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Must return the query builder for the model

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                  refresh: (instance: LucidRow) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Refresh model instance to reflect new values from the database

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: (instance: LucidRow, attributes: ModelObject) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Perform update

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LazyLoadAggregatesContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LazyLoadAggregatesContract<Model extends LucidRow> extends Promise<void> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Lazy load aggregates for a given model instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property loadAggregate

                                                                                                                                                                                                                                                                                                                                                                                                                                                  loadAggregate: WithAggregate<Model, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loadCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                    loadCount: WithCount<Model, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method exec

                                                                                                                                                                                                                                                                                                                                                                                                                                                      exec: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LucidModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LucidModel {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Shape of the model static properties. The $ prefix is to denote special properties from the base model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          @note: Since the interface name appears next to the inherited model methods, we have to choose a succinct name

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $adapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $adapter: AdapterContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Adapter to work as a bridge between query builder and the model

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $columnsDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $columnsDefinitions: Map<string, ModelColumnOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A map of defined columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $computedDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $computedDefinitions: Map<string, ComputedOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A map of computed properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $hooks: Hooks;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Reference to hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $keys: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        attributesToColumns: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        attributesToSerialized: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        columnsToAttributes: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        columnsToSerialized: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializedToColumns: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializedToAttributes: ModelKeysContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A copy of internal keys mapping. One should be able to resolve between all key versions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $relationsDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $relationsDefinitions: Map<string, RelationshipsContract>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A map of defined relationships

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property booted

                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly booted: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Whether or not model has been booted. After this model configurations are ignored

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                        connection?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Custom database connection to use

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property namingStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                        namingStrategy: NamingStrategyContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Naming strategy to use

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property primaryKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                        primaryKey: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The primary key for finding unique referencing to a model

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property selfAssignPrimaryKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                        selfAssignPrimaryKey: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Self assign the primary instead of relying on the database to return it back

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property table

                                                                                                                                                                                                                                                                                                                                                                                                                                                        table: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Database table to use

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $addColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $addColumn: (name: string, options: Partial<ColumnOptions>) => ColumnOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $addComputed

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $addComputed: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: Partial<ComputedOptions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ComputedOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing computed columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $addRelation

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $addRelation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: ModelRelationTypes['__opaque_type'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                        relatedModel: () => LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: ModelRelationOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing relationships

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $createFromAdapterResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $createFromAdapterResult: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        result?: ModelObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        sideloadAttributes?: ModelObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => null | InstanceType<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creating model from adapter results

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $createMultipleFromAdapterResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $createMultipleFromAdapterResult: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        results: ModelObject[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                        sideloadAttributes?: ModelObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => InstanceType<T>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creating multiple model instances from an array of adapter result

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $defineProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $defineProperty: <Model extends LucidModel, Prop extends keyof Model>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        propertyName: Prop,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue: Model[Prop],
                                                                                                                                                                                                                                                                                                                                                                                                                                                        strategy: 'inherit' | 'define' | ((value: Model[Prop]) => Model[Prop])
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Define a static property on the model using the inherit or define strategy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Inherit strategy will clone the property from the parent model and will set it on the current model

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $getColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                        $getColumn: (name: string) => ModelColumnOptions | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method $getComputed

                                                                                                                                                                                                                                                                                                                                                                                                                                                          $getComputed: (name: string) => ComputedOptions | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method $getRelation

                                                                                                                                                                                                                                                                                                                                                                                                                                                            $getRelation: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            <
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Model extends LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Name extends ExtractModelRelations<InstanceType<Model>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: Name
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): InstanceType<Model>[Name] extends ModelRelations
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? InstanceType<Model>[Name]['client']['relation']
                                                                                                                                                                                                                                                                                                                                                                                                                                                            : RelationshipsContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            <Model extends LucidModel>(this: Model, name: string): RelationshipsContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get relationship declaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method $hasColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                            $hasColumn: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method $hasComputed

                                                                                                                                                                                                                                                                                                                                                                                                                                                              $hasComputed: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method $hasRelation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                $hasRelation: (name: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find if a relationship exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method after

                                                                                                                                                                                                                                                                                                                                                                                                                                                                after: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: 'fetch',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<InstanceType<Model>[], 'fetch'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: 'paginate',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ModelPaginatorContract<InstanceType<Model>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'paginate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel, Event extends EventsList>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: Event,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<InstanceType<Model>, Event>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Register an after hook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                all: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Fetch all rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method before

                                                                                                                                                                                                                                                                                                                                                                                                                                                                before: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel, Event extends 'find' | 'fetch'>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: Event,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<ModelQueryBuilderContract<Model>, Event>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: 'paginate',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ModelQueryBuilderContract<Model, InstanceType<Model>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ModelQueryBuilderContract<Model, InstanceType<Model>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                'paginate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <Model extends LucidModel, Event extends EventsList>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                event: Event,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: HooksHandler<InstanceType<Model>, Event>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Register a before hook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method boot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                boot: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Boot model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                create: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                values: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Create model and return its instance back

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                createMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                values: Partial<ModelAttributes<InstanceType<T>>>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Create many of model instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fetchOrCreateMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchOrCreateMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                predicate:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | keyof ModelAttributes<InstanceType<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (keyof ModelAttributes<InstanceType<T>>)[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: Partial<ModelAttributes<InstanceType<T>>>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find rows or create many when missing. One db call is invoked for each create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fetchOrNewUpMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchOrNewUpMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                predicate:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | keyof ModelAttributes<InstanceType<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (keyof ModelAttributes<InstanceType<T>>)[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: Partial<ModelAttributes<InstanceType<T>>>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find rows or create in-memory instances of the missing one's.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method find

                                                                                                                                                                                                                                                                                                                                                                                                                                                                find: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<null | InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find one using the primary key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                findBy: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<null | InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find one using a key-value pair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findByOrFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                findByOrFail: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find one using a key-value pair or fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                findMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find many using an array of primary keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findOrFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                findOrFail: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Find one using the primary key or fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                first: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<null | InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Same as query().first()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method firstOrCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                firstOrCreate: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                savePayload?: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the first row or save it to the database

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method firstOrFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                firstOrFail: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Same as query().firstOrFail()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method firstOrNew

                                                                                                                                                                                                                                                                                                                                                                                                                                                                firstOrNew: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                savePayload?: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the first row or create a new instance of model without persisting it

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: <Model extends LucidModel, Result = InstanceType<Model>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ModelQueryBuilderContract<Model, Result>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the query for fetching a model instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method truncate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                truncate: (cascade?: boolean) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Truncate model table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateOrCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                updateOrCreate: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                updatePayload: Partial<ModelAttributes<InstanceType<T>>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the first row or save it to the database

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateOrCreateMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                updateOrCreateMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                predicate:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | keyof ModelAttributes<InstanceType<T>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (keyof ModelAttributes<InstanceType<T>>)[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: Partial<ModelAttributes<InstanceType<T>>>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: ModelAssignOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<InstanceType<T>[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Update existing rows or create new one's.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                new (): LucidRow;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LucidRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LucidRow {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Shape of the model instance. We prefix the properties with a $ to differentiate between special properties provided by the base model but with exception to save, delete, fill, merge and toJSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @note: Since the interface name appears next to the inherited model methods, we have to choose a succinct name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property $attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $attributes: ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property $columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $columns: undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Columns is a property to get type information for model attributes. This must be declared by the end user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property $dirty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $dirty: ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property $extras

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $extras: ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $isDeleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $isDeleted: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property $isDirty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $isDirty: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property $isLocal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $isLocal: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property $isNew

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $isNew: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property $isPersisted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $isPersisted: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property $options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $options?: ModelOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property $original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $original: ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property $preloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $preloaded: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [relation: string]: LucidRow | LucidRow[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $primaryKeyValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $primaryKeyValue?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property $sideloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $sideloaded: ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property $trx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $trx?: TransactionClientContract;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              load: LucidRowPreload<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Load relationships onto the instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property loadAggregate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loadAggregate: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Self extends this,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Name extends ExtractModelRelations<Self>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RelatedBuilder = Self[Name] extends ModelRelations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ? Self[Name]['subQuery']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: Name,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (builder: RelatedBuilder) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => LazyLoadAggregatesContract<Self>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Load aggregates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property loadCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loadCount: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Self extends this,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Name extends ExtractModelRelations<Self>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RelatedBuilder = Self[Name] extends ModelRelations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ? Self[Name]['subQuery']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: Name,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback?: (builder: RelatedBuilder) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => LazyLoadAggregatesContract<Self>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Load count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property preload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preload: LucidRowPreload<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Alias for "load"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method $consumeAdapterResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $consumeAdapterResult: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              adapterResult: ModelObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sideloadAttributes?: ModelObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Consume the adapter result and hydrate the model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method $getAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $getAttribute: (key: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method $getAttributeFromCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $getAttributeFromCache: (key: string, callback: CacheNode['getter']) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method $getQueryFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $getQueryFor: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (action: 'insert', client: QueryClientContract): ReturnType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  QueryClientContract['insertQuery']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  action: 'update' | 'delete' | 'refresh',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  client: QueryClientContract
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): ModelQueryBuilderContract<LucidModel, LucidRow>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Gives an option to the end user to define constraints for update, insert and delete queries. Since the query builder for these queries aren't exposed to the end user, this method opens up the API to build custom queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method $getRelated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $getRelated: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultValue?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => OneOrMany<LucidRow> | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $hasRelated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $hasRelated: (key: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Read/write realtionships. Following methods are intentionally loosely typed, so that one can bypass the public facing API and type checking for advanced use cases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $hydrateOriginals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $hydrateOriginals: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method $pushRelated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $setAttribute: (key: string, value: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Read/write attributes. Following methods are intentionally loosely typed, so that one can bypass the public facing API and type checking for advanced use cases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $setOptionsAndTrx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $setOptionsAndTrx: (options?: ModelAdapterOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method $setRelated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            delete: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method fill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fill: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: Partial<ModelAttributes<this>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allowExtraProperties?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: Partial<ModelAttributes<this>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                allowExtraProperties?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  refresh: () => Promise<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method related

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    related: <Name extends ExtractModelRelations<this>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    relation: Name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this[Name] extends ModelRelations ? this[Name]['client'] : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns related model for a given relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method save

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    save: () => Promise<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Actions to perform on the instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serialize: (cherryPick?: CherryPick) => ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize model to a plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serializeAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize attributes to a plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serializeComputed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serializeComputed: (fields?: CherryPickFields) => ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize computed properties to a plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serializeRelations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serializeRelations: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[] };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (cherryPick: { [relation: string]: CherryPick }, raw: false): ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cherryPick?: { [relation: string]: CherryPick },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    raw?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize relationships to key-value pair of model instances and their serializeAs keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize relationships to key-value pair of plain nested objects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJSON: () => ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Serialize everything

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toObject: () => ModelObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Converts model to an object. It just returns the properties of the model, along with preloaded relationships

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method useConnection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    useConnection: (connection: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method useTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      useTransaction: (trx: TransactionClientContract) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LucidRowAggregate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LucidRowAggregate<Model extends LucidRow>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends Preload<Model, Promise<void>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (callback: (preloader: PreloaderContract<Model>) => void): Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface LucidRowPreload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface LucidRowPreload<Model extends LucidRow>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extends Preload<Model, Promise<void>> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Preload function on a model instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (callback: (preloader: PreloaderContract<Model>) => void): Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ModelKeysContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ModelKeysContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Shape of model keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              add: (key: string, value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                all: () => ModelObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: string, defaultValue: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: string, defaultValue?: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolve: (key: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModelObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModelObject {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Reusable interface to define an object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModelPaginatorContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModelPaginatorContract<Result extends LucidRow>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends Omit<SimplePaginatorContract<Result>, 'toJSON'> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An extension of the simple paginator with support for serializing models

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serialize: (cherryPick?: CherryPick) => { meta: any; data: ModelObject[] };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toJSON: () => { meta: any; data: ModelObject[] };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ModelQueryBuilderContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ModelQueryBuilderContract<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Model extends LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Result = InstanceType<Model>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > extends ChainableContract,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ExcutableQueryBuilderContract<Result[]> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Model query builder will have extras methods on top of the Database query builder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property andDoesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            andDoesntHave: Has<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property andHas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              andHas: Has<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property andWhereDoesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                andWhereDoesntHave: WhereHas<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property andWhereHas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  andWhereHas: WhereHas<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property avg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    avg: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property avgDistinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      avgDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        client: QueryClientContract;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Reference to query client used for making queries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property clientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly clientOptions: ModelAdapterOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A copy of client options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: Aggregate<this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Aggregates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property countDistinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        countDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property decrement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          decrement: Counter<ModelQueryBuilderContract<Model, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property doesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            doesntHave: Has<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              has: Has<InstanceType<Model>, this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add where constraint using the relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property increment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              increment: Counter<ModelQueryBuilderContract<Model, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isChildQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isChildQuery: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Whether or not the query is a child query generated for .where callbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                max: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  min: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    model: Model;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property orDoesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      orDoesntHave: Has<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property orHas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        orHas: Has<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property orWhereDoesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          orWhereDoesntHave: WhereHas<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property orWhereHas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            orWhereHas: WhereHas<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property preload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preload: Preload<InstanceType<Model>, this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Define relationships to be preloaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property returning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              returning: Returning<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sum: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sumDistinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sumDistinct: Aggregate<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    update: Update<ModelQueryBuilderContract<Model, any>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Mutations (update and increment can be one query aswell)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property whereDoesntHave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    whereDoesntHave: WhereHas<InstanceType<Model>, this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property whereHas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      whereHas: WhereHas<InstanceType<Model>, this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Add where constraint using the relationship with a custom callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property withAggregate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withAggregate: WithAggregate<InstanceType<Model>, this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Fetch aggregate value for a given relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property withCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withCount: WithCount<InstanceType<Model>, this>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Fetch relationship count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: <Scopes extends ExtractScopes<Model>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (scopes: Scopes) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Alias for the method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clone: <ClonedResult = Result>() => ModelQueryBuilderContract<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Model,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ClonedResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Clone query builder instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method del

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      del: (returning?: OneOrMany<string>) => ModelQueryBuilderContract<Model, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Perform delete operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      delete: (returning?: OneOrMany<string>) => ModelQueryBuilderContract<Model, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        first: () => Promise<Result | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Execute and get first result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method firstOrFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        firstOrFail: () => Promise<Result>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Return the first matching row or fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method forPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forPage: (page: number, perPage?: number) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A shorthand to define limit and offset based upon the current page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method ifDialect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ifDialect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dialect: DialectContract['name'] | DialectContract['name'][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Executes the callback when dialect matches one of the mentioned dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method paginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paginate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        page: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        perPage?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Result extends LucidRow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ? ModelPaginatorContract<Result>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        : SimplePaginatorContract<Result>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Execute query with pagination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pojo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pojo: <T>() => ModelQueryBuilderContract<Model, T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get rows back as a plain javascript object and not an array of model instances

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method rowTransformer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rowTransformer: (callback: (row: LucidRow) => void) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Define a callback to transform a row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sideload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sideload: (value: ModelObject) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A custom set of sideloaded properties defined on the query builder, this will be passed to the model instance created by the query builder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method unlessDialect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unlessDialect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dialect: DialectContract['name'] | DialectContract['name'][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        matchCallback: (query: this) => any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        noMatchCallback?: (query: this) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Executes the callback when dialect matches doesn't all the mentioned dialects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method usePreloader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        usePreloader: (preloader: PreloaderContract<LucidRow>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Define a custom preloader for the current query