import { Column, TableData, ColumnsShape, Query, RelationConfigBase, QueryManyTake, QueryManyTakeOptional, EmptyObject, CreateData, UpdateData, WhereArg, SelectableFromShape, CreateManyMethodsNames, QueryHasWhere, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, StorageOptions, DbSharedOptions, QuerySchema, ColumnSchemaConfig, DbSqlMethod, TableDataItem, QueryData, IsQuery, TableDataFn, ComputedOptionsFactory, DbTableOptionScopes, QueryScopes, RecordUnknown, QueryBeforeHook, QueryAfterHook, QueryBeforeActionHook, AfterHook, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, ComputedOptionsConfig, QueryOrExpression, DefaultSchemaConfig, DefaultColumnTypes, QueryReturnType, MergeQuery } from 'pqb/internal';
export * from 'pqb';

interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
    required?: boolean;
    columns: Column[];
    references: (keyof Shape)[];
    foreignKey?: boolean | TableData.References.Options;
    on?: ColumnsShape.InputPartial<Shape>;
}
interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
    through: Through;
    source: Source;
}

interface HasOne extends RelationThunkBase {
    type: 'hasOne';
    options: HasOneOptions;
}
interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
    required?: boolean;
}
type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? {
    [Name in Options['columns'][number]]: T['columns']['shape'][Name]['type'];
} : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
type HasOneQueryThrough<Name extends string, TableQuery extends Query> = {
    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K];
} & QueryHasWhere & HasRelJoin;
type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
    [K in keyof TableQuery]: K extends '__defaults' ? {
        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K];
} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
    returnsOne: true;
    query: Q;
    params: HasOneParams<T, Rel['options']>;
    maybeSingle: T['relations'][Name]['options']['required'] extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
    omitForeignKeyInCreate: never;
    optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
        [P in Name]?: RelationToOneDataForCreate<{
            nestedCreateQuery: CreateData<Q>;
            table: Q;
        }>;
    };
    dataForCreate: never;
    dataForUpdate: {
        disconnect: boolean;
    } | {
        delete: boolean;
    } | {
        update: UpdateData<Q>;
    };
    dataForUpdateOne: {
        disconnect: boolean;
    } | {
        set: WhereArg<Q>;
    } | {
        delete: boolean;
    } | {
        update: UpdateData<Q>;
    } | {
        upsert: {
            update: UpdateData<Q>;
            create: CreateData<Q> | (() => CreateData<Q>);
        };
    } | {
        create: CreateData<Q>;
    };
}

interface HasMany extends RelationThunkBase {
    type: 'hasMany';
    options: HasOneOptions;
}
type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? {
    [K in keyof TableQuery]: K extends '__defaults' ? {
        [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true;
    } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
} & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany, Q extends Query> extends RelationConfigBase {
    returnsOne: false;
    query: Q;
    params: HasOneParams<T, Rel['options']>;
    maybeSingle: Q;
    omitForeignKeyInCreate: never;
    optionalDataForCreate: {
        [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
            create?: CreateData<Q>[];
            connect?: WhereArg<Q>[];
            connectOrCreate?: {
                where: WhereArg<Q>;
                create: CreateData<Q>;
            }[];
        };
    };
    dataForCreate: never;
    dataForUpdate: {
        disconnect?: MaybeArray<WhereArg<Q>>;
        delete?: MaybeArray<WhereArg<Q>>;
        update?: {
            where: MaybeArray<WhereArg<Q>>;
            data: UpdateData<Q>;
        };
    };
    dataForUpdateOne: {
        disconnect?: MaybeArray<WhereArg<Q>>;
        delete?: MaybeArray<WhereArg<Q>>;
        update?: {
            where: MaybeArray<WhereArg<Q>>;
            data: UpdateData<Q>;
        };
        set?: MaybeArray<WhereArg<Q>>;
        add?: MaybeArray<WhereArg<Q>>;
        create?: CreateData<Q>[];
    };
}

interface RelJoin extends JoinQueryMethod {
    <T extends Query>(this: T): T;
}
interface HasRelJoin {
    join: RelJoin;
}

interface BelongsTo extends RelationThunkBase {
    type: 'belongsTo';
    options: BelongsToOptions;
}
interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
    required?: boolean;
    columns: (keyof Columns)[];
    references: (keyof Related['columns']['shape'])[];
    foreignKey?: boolean | TableData.References.Options;
    on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
}
type BelongsToParams<T extends RelationConfigSelf, FK extends string> = {
    [Name in FK]: T['columns']['shape'][Name]['type'];
};
type BelongsToQuery<T extends Query, Name extends string> = {
    [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P];
} & QueryHasWhere & HasRelJoin;
interface BelongsToInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Required, Q extends Query> extends RelationConfigBase {
    returnsOne: true;
    query: Q;
    params: BelongsToParams<T, FK>;
    maybeSingle: Required extends true ? QueryManyTake<Q> : QueryManyTakeOptional<Q>;
    omitForeignKeyInCreate: FK;
    dataForCreate: {
        columns: FK;
        nested: Required extends true ? {
            [Key in Name]: RelationToOneDataForCreateSameQuery<Q>;
        } : {
            [Key in Name]?: RelationToOneDataForCreateSameQuery<Q>;
        };
    };
    optionalDataForCreate: EmptyObject;
    dataForUpdate: {
        disconnect: boolean;
    } | {
        set: WhereArg<Q>;
    } | {
        delete: boolean;
    } | {
        update: UpdateData<Q>;
    } | {
        create: CreateData<Q>;
    };
    dataForUpdateOne: {
        disconnect: boolean;
    } | {
        set: WhereArg<Q>;
    } | {
        delete: boolean;
    } | {
        update: UpdateData<Q>;
    } | {
        create: CreateData<Q>;
    } | {
        upsert: {
            update: UpdateData<Q>;
            create: CreateData<Q> | (() => CreateData<Q>);
        };
    };
}

declare function transaction<Result>(this: {
    $qb: Db;
}, fn: () => Promise<Result>): Promise<Result>;
declare function transaction<Result>(this: {
    $qb: Db;
}, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
declare function ensureTransaction<Result>(this: {
    $qb: Db;
}, cb: () => Promise<Result>): Promise<Result>;
declare function isInTransaction(this: {
    $qb: Db;
}): boolean;
declare function afterCommit(this: {
    $qb: Db;
}, hook: AfterCommitStandaloneHook): void;

interface FromQuery extends Query {
    returnType: 'all';
}
type OrchidORM<T extends TableClasses = TableClasses> = {
    [K in keyof T]: T[K] extends {
        new (): infer R extends ORMTableInput;
    } ? TableToDb<R> : never;
} & OrchidORMMethods;
interface OrchidORMMethods {
    /**
     * @see import('pqb').QueryTransaction.prototype.transaction
     */
    $transaction: typeof transaction;
    /**
     * @see import('pqb').QueryTransaction.prototype.ensureTransaction
     */
    $ensureTransaction: typeof ensureTransaction;
    /**
     * @see import('pqb').QueryTransaction.prototype.isInTransaction
     */
    $isInTransaction: typeof isInTransaction;
    /**
     * @see import('pqb').QueryTransaction.prototype.afterCommit
     */
    $afterCommit: typeof afterCommit;
    $qb: Db;
    $adapterNotInTransaction: AdapterBase;
    /**
     * Adapter is a wrapper on top of `postgres-js`, `node-postgres`, or other db driver.
     *
     * When in transaction, returns a db adapter object for the transaction,
     * returns a default adapter object otherwise.
     *
     * Treat the adapter as implementation detail and avoid accessing it directly.
     */
    $getAdapter(): AdapterBase;
    /**
     * Use `$query` to perform raw SQL queries.
     *
     * ```ts
     * const value = 1;
     *
     * // it is safe to interpolate inside the backticks (``):
     * const result = await db.$query<{ one: number }>`SELECT ${value}  one`;
     * // data is inside `rows` array:
     * result.rows[0].one;
     * ```
     *
     * If the query is executing inside a transaction, it will use the transaction connection automatically.
     *
     * ```ts
     * await db.transaction(async () => {
     *   // both queries will execute in the same transaction
     *   await db.$query`SELECT 1`;
     *   await db.$query`SELECT 2`;
     * });
     * ```
     *
     * Alternatively, support a simple SQL string, with optional `values`:
     *
     * Note that the values is a simple array, and the SQL is referring to the values with `$1`, `$2` and so on.
     *
     * ```ts
     * const value = 1;
     *
     * // it is NOT safe to interpolate inside a simple string, use `values` to pass the values.
     * const result = await db.$query<{ one: number }>({
     *   raw: 'SELECT $1 AS one',
     *   values: [value],
     * });
     * // data is inside `rows` array:
     * result.rows[0].one;
     * ```
     *
     * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
     */
    $query: Db['query'];
    /**
     * The same as the {@link $query}, but returns an array of arrays instead of objects:
     *
     * ```ts
     * const value = 1;
     *
     * // it is safe to interpolate inside the backticks (``):
     * const result = await db.$queryArrays<[number]>`SELECT ${value} AS one`;
     * // `rows` is an array of arrays:
     * const row = result.rows[0];
     * row[0]; // our value
     * ```
     *
     * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
     */
    $queryArrays: Db['queryArrays'];
    /**
     * See {@link FromMethods.from}
     */
    $from<Arg extends MaybeArray<FromArg<Query>>>(arg: Arg): FromResult<FromQuery, Arg>;
    /**
     * `$withOptions` supports overriding `log` and `schema`.
     *
     * - `log`: boolean, enables or disables logging in the scope of the callback.
     * - `schema`: set a **default** schema, note that it does not override
     *   if you already have a schema set in the ORM config or for a specific table.
     *
     * ```ts
     * await db.$withOptions({ log: true, schema: 'custom' }, async () => {
     *   // will log this query, and will use the custom schema for this table,
     *   // unless this table already has a configured schema.
     *   await db.table.find(123);
     * });
     * ```
     */
    $withOptions<Result>(options: StorageOptions, cb: () => Promise<Result>): Promise<Result>;
    $close(): Promise<void>;
}
type OrchidOrmParam<Options> = true | null extends true ? 'Set strict: true to tsconfig' : Options;
declare const orchidORMWithAdapter: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, schema, ...options }: OrchidOrmParam<({
    db: Query;
} | {
    adapter: AdapterBase;
}) & DbSharedOptions>, tables: T) => OrchidORM<T>;

interface HasAndBelongsToMany extends RelationThunkBase {
    type: 'hasAndBelongsToMany';
    options: HasAndBelongsToManyOptions;
}
interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
    required?: boolean;
    columns: (keyof Columns)[];
    references: string[];
    foreignKey?: boolean | TableData.References.Options;
    through: {
        schema?: QuerySchema;
        table: string;
        columns: string[];
        references: (keyof Related['columns']['shape'])[];
        foreignKey?: boolean | TableData.References.Options;
    };
    on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
}
type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = {
    [Name in FK]: T['columns']['shape'][Name]['type'];
};
type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = {
    [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K];
} & QueryHasWhere & HasRelJoin;
interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Q extends Query> extends RelationConfigBase {
    returnsOne: false;
    query: Q;
    params: HasAndBelongsToManyParams<T, FK>;
    maybeSingle: Q;
    omitForeignKeyInCreate: never;
    optionalDataForCreate: {
        [P in Name]?: {
            create?: CreateData<Q>[];
            connect?: WhereArg<Q>[];
            connectOrCreate?: {
                where: WhereArg<Q>;
                create: CreateData<Q>;
            }[];
        };
    };
    dataForCreate: never;
    dataForUpdate: {
        disconnect?: MaybeArray<WhereArg<Q>>;
        set?: MaybeArray<WhereArg<Q>>;
        add?: MaybeArray<WhereArg<Q>>;
        delete?: MaybeArray<WhereArg<Q>>;
        update?: {
            where: MaybeArray<WhereArg<Q>>;
            data: UpdateData<Q>;
        };
        create?: CreateData<Q>[];
    };
    dataForUpdateOne: {
        disconnect?: MaybeArray<WhereArg<Q>>;
        set?: MaybeArray<WhereArg<Q>>;
        add?: MaybeArray<WhereArg<Q>>;
        delete?: MaybeArray<WhereArg<Q>>;
        update?: {
            where: MaybeArray<WhereArg<Q>>;
            data: UpdateData<Q>;
        };
        create?: CreateData<Q>[];
    };
}

type RelationToOneDataForCreate<Rel extends {
    nestedCreateQuery: unknown;
    table: Query;
}> = {
    create: Rel['nestedCreateQuery'];
    connect?: never;
    connectOrCreate?: never;
} | {
    create?: never;
    connect: WhereArg<Rel['table']>;
    connectOrCreate?: never;
} | {
    create?: never;
    connect?: never;
    connectOrCreate: {
        where: WhereArg<Rel['table']>;
        create: Rel['nestedCreateQuery'];
    };
};
type RelationToOneDataForCreateSameQuery<Q extends Query> = {
    create: CreateData<Q>;
    connect?: never;
    connectOrCreate?: never;
} | {
    create?: never;
    connect: WhereArg<Q>;
    connectOrCreate?: never;
} | {
    create?: never;
    connect?: never;
    connectOrCreate: {
        where: WhereArg<Q>;
        create: CreateData<Q>;
    };
};
interface RelationThunkBase {
    type: string;
    related: ORMTableInput;
    options: unknown;
}
type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
interface RelationThunks {
    [K: string]: RelationThunk;
}
type RelationTableToQuery<Relation> = Relation extends {
    related: infer R extends ORMTableInput;
} ? TableToDb<R> : never;
interface RelationConfigSelf {
    columns: {
        shape: Column.Shape.QueryInit;
    };
    relations: RelationThunks;
}
type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation['options']['columns'][number] & string> : Relation extends HasOne | HasMany ? HasOneParams<T, Relation['options']> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation['options']['columns'][number] & string> : never;

interface TableClass<T extends ORMTableInput = ORMTableInput> {
    new (): T;
}
interface TableClasses {
    [K: string]: TableClass;
}
interface TableInfo {
    definedAs: string;
    db: OrchidORM;
    getFilePath(): string;
    name: string;
}
interface Table extends Query, TableInfo {
}
interface TableToDb<T extends ORMTableInput> extends TableInfo, Db<T['table'], T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, T['types'], T['columns']['shape'] & ComputedColumnsFromOptions<T['computed']>, MapTableScopesOption<T>, ColumnsShape.DefaultSelectKeys<T['columns']['shape']>> {
    relations: T extends RelationConfigSelf ? {
        [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, T['relations'][K]['options']['columns'][number] & string, T['relations'][K]['options']['required'], BelongsToQuery<RelationTableToQuery<T['relations'][K]>, K>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never;
    } : EmptyObject;
}
interface ORMTableInput {
    table: string;
    columns: {
        shape: Column.Shape.QueryInit;
        data: MaybeArray<TableDataItem>;
    };
    schema?: QuerySchema;
    types: unknown;
    noPrimaryKey?: boolean;
    filePath: string;
    language?: string;
    /**
     * collect computed columns returned by {@link BaseTable.setColumns}
     */
    computed?: ComputedOptionsFactory<never, never>;
    scopes?: RecordUnknown;
    readonly softDelete?: true | string;
    comment?: string;
    autoForeignKeys?: TableData.References.BaseOptions | boolean;
}
type Queryable<T extends ORMTableInput> = ShallowSimplify<{
    [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
}>;
type DefaultSelect<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.DefaultOutput<T['columns']['shape']>>;
type Selectable<T extends ORMTableInput> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnsShape.Output<T['columns']['shape']> & {
    [K in keyof R]: R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value']['outputType'] : R[K] extends () => {
        result: {
            value: infer Value extends Column.Pick.QueryColumn;
        };
    } ? Value['outputType'] : never;
}> : ShallowSimplify<ColumnsShape.Output<T['columns']['shape']>>;
type Insertable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.Input<T['columns']['shape']>>;
type Updatable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.InputPartial<T['columns']['shape']>>;
type BeforeHookMethod = (cb: QueryBeforeHook) => void;
type BeforeActionHookMethod = (cb: QueryBeforeActionHook) => void;
type AfterHookMethod = (cb: QueryAfterHook) => void;
type AfterSelectableHookMethod = <Shape extends Column.QueryColumns, S extends (keyof Shape)[]>(this: {
    columns: {
        shape: Shape;
    };
}, select: S, cb: AfterHook<S, Shape>) => void;
interface SetColumnsResult<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
    shape: Shape;
    data: Data extends unknown[] ? Data : [Data];
}
interface BaseTableInstance<ColumnTypes> {
    table: string;
    columns: {
        shape: Column.Shape.QueryInit;
        data: MaybeArray<TableDataItem>;
    };
    schema?: QuerySchema;
    noPrimaryKey?: boolean;
    snakeCase?: boolean;
    types: ColumnTypes;
    q: QueryData;
    language?: string;
    filePath: string;
    result: Column.Shape.QueryInit;
    clone<T extends IsQuery>(this: T): T;
    getFilePath(): string;
    setColumns<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<TableDataItem>>(fn: (t: ColumnTypes) => Shape, tableData?: TableDataFn<Shape, Data>): SetColumnsResult<Shape, Data>;
    /**
     * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
     * such column will persist in the database, it can be indexed.
     *
     * Or you can add a computed column on the ORM level, without adding it to the database, in such a way:
     *
     * ```ts
     * import { BaseTable, sql } from './baseTable';
     *
     * export class UserTable extends BaseTable {
     *   readonly table = 'user';
     *   columns = this.setColumns((t) => ({
     *     id: t.identity().primaryKey(),
     *     firstName: t.string(),
     *     lastName: t.string(),
     *   }));
     *
     *   computed = this.setComputed({
     *     fullName: (q) =>
     *       sql`${q.column('firstName')} || ' ' || ${q.column('lastName')}`.type(
     *         (t) => t.string(),
     *       ),
     *   });
     * }
     * ```
     *
     * `setComputed` takes an object where keys are computed column names, and values are functions returning raw SQL.
     *
     * Use `q.column` as shown above to reference a table column, it will be prefixed with a correct table name even if the table is joined under a different name.
     *
     * Computed columns are not selected by default, only on demand:
     *
     * ```ts
     * const a = await db.user.take();
     * a.fullName; // not selected
     *
     * const b = await db.user.select('*', 'fullName');
     * b.fullName; // selected
     *
     * // Table post belongs to user as an author.
     * // it's possible to select joined computed column:
     * const posts = await db.post
     *   .join('author')
     *   .select('post.title', 'author.fullName');
     * ```
     *
     * SQL query can be generated dynamically based on the current request context.
     *
     * Imagine we are using [AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynchronous-context-tracking)
     * to keep track of current user's language.
     *
     * And we have articles translated to different languages, each article has `title_en`, `title_uk`, `title_be` and so on.
     *
     * We can define a computed `title` by passing a function into `sql` method:
     *
     * ```ts
     * import { sql } from './baseTable';
     *
     * type Locale = 'en' | 'uk' | 'be';
     * const asyncLanguageStorage = new AsyncLocalStorage<Locale>();
     * const defaultLocale: Locale = 'en';
     *
     * export class ArticleTable extends BaseTable {
     *   readonly table = 'article';
     *   columns = this.setColumns((t) => ({
     *     id: t.identity().primaryKey(),
     *     title_en: t.text(),
     *     title_uk: t.text().nullable(),
     *     title_be: t.text().nullable(),
     *   }));
     *
     *   computed = this.setComputed({
     *     title: () =>
     *       // `sql` accepts a callback to generate a new query on every run
     *       sql(() => {
     *         // get locale dynamically based on current storage value
     *         const locale = asyncLanguageStorage.getStore() || defaultLocale;
     *
     *         // use COALESCE in case when localized title is NULL, use title_en
     *         return sql`COALESCE(
     *             ${q.column(`title_${locale}`)},
     *             ${q.column(`title_${defaultLocale}`)}
     *           )`;
     *       }).type((t) => t.text()),
     *   });
     * }
     * ```
     *
     * @param computed - object where keys are column names and values are functions returning raw SQL
     */
    setComputed<Shape extends Column.Shape.QueryInit, Computed extends ComputedOptionsFactory<ColumnTypes, Shape>>(this: {
        columns: {
            shape: Shape;
        };
    }, computed: Computed): Computed;
    /**
     * See {@link ScopeMethods}
     */
    setScopes<Table extends string, Shape extends Column.Shape.QueryInit, Keys extends string>(this: {
        table: Table;
        columns: {
            shape: Shape;
        };
    }, scopes: DbTableOptionScopes<Table, Shape, Keys>): QueryScopes<Keys>;
    belongsTo<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends BelongsToOptions<Columns, Related>>(this: {
        columns: {
            shape: Columns;
        };
    }, fn: () => {
        new (): Related;
    }, options: Options): {
        type: 'belongsTo';
        related: Related;
        options: Options;
    };
    hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
        columns: {
            shape: Columns;
        };
    }, fn: () => {
        new (): Related;
    }, options: Options): {
        type: 'hasOne';
        related: Related;
        options: Options;
    };
    hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
        columns: {
            shape: Columns;
        };
    }, fn: () => {
        new (): Related;
    }, options: Options): {
        type: 'hasMany';
        related: Related;
        options: Options;
    };
    hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
        columns: {
            shape: Columns;
        };
    }, fn: () => {
        new (): Related;
    }, options: Options): {
        type: 'hasAndBelongsToMany';
        related: Related;
        options: Options;
    };
    beforeQuery: BeforeHookMethod;
    afterQuery: AfterHookMethod;
    beforeCreate: BeforeActionHookMethod;
    afterCreate: AfterSelectableHookMethod;
    afterCreateCommit: AfterSelectableHookMethod;
    beforeUpdate: BeforeActionHookMethod;
    afterUpdate: AfterSelectableHookMethod;
    afterUpdateCommit: AfterSelectableHookMethod;
    beforeSave: BeforeActionHookMethod;
    afterSave: AfterSelectableHookMethod;
    afterSaveCommit: AfterSelectableHookMethod;
    beforeDelete: BeforeHookMethod;
    afterDelete: AfterSelectableHookMethod;
    afterDeleteCommit: AfterSelectableHookMethod;
}
interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
    nowSQL: string | undefined;
    exportAs: string;
    columnTypes: ColumnTypes;
    getFilePath(): string;
    sql: DbSqlMethod<ColumnTypes>;
    new (): BaseTableInstance<ColumnTypes>;
    instance(): BaseTableInstance<ColumnTypes>;
    /**
     * All column types for inserting.
     */
    inputSchema: SchemaConfig['inputSchema'];
    /**
     * All column types as returned from a database.
     */
    outputSchema: SchemaConfig['outputSchema'];
    /**
     * All column types for query methods such as `where`.
     */
    querySchema: SchemaConfig['querySchema'];
    /**
     * Primary key column(s) type for query methods such as `where`.
     */
    pkeySchema: SchemaConfig['pkeySchema'];
    /**
     * Column types for inserting, excluding primary keys.
     * Equals to {@link inputSchema} without primary keys.
     */
    createSchema: SchemaConfig['createSchema'];
    /**
     * Column types for updating, excluding primary keys.
     * Equals to partial {@link createSchema}.
     */
    updateSchema: SchemaConfig['updateSchema'];
}
declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, autoForeignKeys, }?: {
    schemaConfig?: SchemaConfig;
    columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
    snakeCase?: boolean;
    filePath?: string;
    nowSQL?: string;
    exportAs?: string;
    language?: string;
    autoForeignKeys?: boolean | TableData.References.BaseOptions;
}): BaseTableClass<SchemaConfig, ColumnTypes>;

type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
type QueryOne<T extends Query> = {
    [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all' | undefined> : T[K];
};
interface MethodsBase<T extends Query> {
    queryMethods?: QueryMethods<T>;
    queryOneMethods?: QueryMethods<QueryOne<T>>;
    queryWithWhereMethods?: QueryMethods<T & QueryHasWhere>;
    queryOneWithWhereMethods?: QueryMethods<QueryOne<T & QueryHasWhere>>;
    methods?: RecordUnknown;
}
type MapQueryMethods<BaseQuery extends Query, Method> = Method extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
type MapMethods<T extends Query, Methods extends MethodsBase<T>> = {
    [K in keyof Methods['queryMethods'] | keyof Methods['queryOneMethods'] | keyof Methods['queryWithWhereMethods'] | keyof Methods['queryOneWithWhereMethods'] | keyof Methods['methods']]: K extends keyof Methods['methods'] ? Methods['methods'][K] : K extends keyof Methods['queryOneWithWhereMethods'] ? MapQueryMethods<QueryOne<Query & QueryHasWhere>, Methods['queryOneWithWhereMethods'][K]> : K extends keyof Methods['queryWithWhereMethods'] ? MapQueryMethods<Query & QueryHasWhere, Methods['queryWithWhereMethods'][K]> : K extends keyof Methods['queryOneMethods'] ? MapQueryMethods<QueryOne<Query>, Methods['queryOneMethods'][K]> : K extends keyof Methods['queryMethods'] ? MapQueryMethods<Query, Methods['queryMethods'][K]> : never;
};
type Repo<T extends Query, Methods extends MethodsBase<T>> = T & MapMethods<T, Methods>;
declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<(<Q extends {
    table: T["table"];
    shape: T["shape"];
}>(q: Q) => Query & Q & MapMethods<T, Methods>) & T, Methods>;

export { createBaseTable, createRepo, orchidORMWithAdapter };
export type { BaseTableClass, BaseTableInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidOrmParam, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableToDb, Updatable };