@adonisjs/lucid

  • Version 15.0.0
  • Published
  • 862 kB
  • 12 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;
                                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 sum

                                                                                                                                                                                                                                                                                          sum: 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: () => this;
                                                                                                                                                                                                                                                                                            • Perform delete operation

                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                            delete: () => 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>[]): Builder;
                                                                                                                                                                                                                                                                                              • An array of values with subqueries

                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                              (...columns: ValueWithSubQueries<string>[]): 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,
                                                                                                                                                                                                                                                                                                                    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,
                                                                                                                                                                                                                                                                                                                    value: (StrictValues | ChainableContract | RawBuilderContract | RawQuery)[]
                                                                                                                                                                                                                                                                                                                    ): Builder;
                                                                                                                                                                                                                                                                                                                    • Key and an array of literal values, raw queries or subqueries.

                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                    (key: string, 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?: string | 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?: string | 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, value: StrictValues | ChainableContract): Builder;
                                                                                                                                                                                                                                                                                                                                                                                              • Key-value pair. The value can also be a subquery

                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                              key: string,
                                                                                                                                                                                                                                                                                                                                                                                              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,
                                                                                                                                                                                                                                                                                                                                                                                                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, comparisonColumn: string): Builder;
                                                                                                                                                                                                                                                                                                                                                                                                • Key-value pair.

                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                (column: string, 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, 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,
                                                                                                                                                                                                                                                                                                                                                                                                    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): 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;
                                                                                                                                                                                                                                                                                                                                                                                                        • 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 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 $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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<InstanceType<T>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Create model and return its instance back

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                      createMany: <T extends LucidModel>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                      this: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      values: Partial<ModelAttributes<InstanceType<T>>>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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?: ModelAdapterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => 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 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 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 sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sum: 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: () => ModelQueryBuilderContract<Model, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Perform delete operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delete: () => 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method withScopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withScopes: <Scopes extends ExtractScopes<Model>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (scopes: Scopes) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Apply model query scopes on the query bulder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NamingStrategyContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NamingStrategyContract {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Naming strategy for model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method columnName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      columnName: (model: LucidModel, attributeName: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The database column name for a given model attribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method paginationMetaKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      paginationMetaKeys: () => SimplePaginatorMetaKeys;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Keys for the pagination meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method relationForeignKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationForeignKey: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relation: ModelRelations['__opaque_type'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      model: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedModel: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The foreign key for a given model relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method relationLocalKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationLocalKey: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relation: ModelRelations['__opaque_type'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      model: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedModel: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The local key for a given model relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method relationPivotForeignKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationPivotForeignKey: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relation: 'manyToMany',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      model: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedModel: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pivot foreign key for many to many relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method relationPivotTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationPivotTable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relation: 'manyToMany',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      model: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedModel: LucidModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relationName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Pivot table name for many to many relationship

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method serializedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializedName: (model: LucidModel, attributeName: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The post serialization name for a given model attribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method tableName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tableName: (model: LucidModel) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The default table name for the given model

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CacheNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CacheNode = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      original: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolved: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getter: (value: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Shape of cache node to keep getters optimized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CherryPick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CherryPick = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fields?: CherryPickFields;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relations?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [relation: string]: CherryPick;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Shape for cherry picking fields on nested relationships

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CherryPickFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CherryPickFields =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pick?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      omit?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Shape for cherry picking fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColumnDecorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColumnDecorator = (options?: Partial<ColumnOptions>) => DecoratorFn;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Signature for column decorator function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColumnOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColumnOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      columnName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializeAs: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isPrimary: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      meta?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Invoked before serializing process happens
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serialize?: (value: any, attribute: string, model<