pqb 0.7.13 → 0.8.1

package/dist/index.d.ts

@@ -25,7 +25,7 @@ declare const getQueryParsers: (q: Query) => ColumnsParsers | undefined;
 declare type BaseRelation = {
     type: string;
     key: string;
-    model: QueryWithTable;
+    table: QueryWithTable;
     query: QueryWithTable;
     joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
     nestedCreateQuery: Query;
@@ -436,8 +436,8 @@ declare type ToSqlOptions = {
     clearCache?: boolean;
     values?: unknown[];
 };
-declare const toSql: (model: Query, options?: ToSqlOptions) => Sql;
-declare const makeSql: (model: Query, { values }?: ToSqlOptions) => Sql;
+declare const toSql: (table: Query, options?: ToSqlOptions) => Sql;
+declare const makeSql: (table: Query, { values }?: ToSqlOptions) => Sql;
 
 declare type SomeIsTrue<T extends unknown[]> = T extends [
     infer Head,
@@ -488,6 +488,7 @@ declare const emptyObject: {};
 declare const makeRegexToFindInSql: (value: string) => RegExp;
 declare const pushOrNewArrayToObject: <Obj extends {}, Key extends keyof Obj>(obj: Obj, key: Key, value: Exclude<Obj[Key], undefined> extends unknown[] ? Exclude<Obj[Key], undefined>[number] : never) => void;
 declare const pushOrNewArray: <Arr extends unknown[]>(arr: Arr | undefined, value: Arr[number]) => Arr;
+declare const singleQuote: (s: string) => string;
 
 declare type ThenResult<Res> = (resolve?: (value: Res) => any, reject?: (error: any) => any) => Promise<Res | never>;
 declare const queryMethodByReturnType: Record<QueryReturnType, 'query' | 'arrays'>;
@@ -518,7 +519,7 @@ declare class QueryGet {
 declare type SelectArg<T extends QueryBase> = StringKey<keyof T['selectable']> | (T['relations'] extends Record<string, Relation> ? StringKey<keyof T['relations']> : never) | SelectAsArg<T>;
 declare type SelectAsArg<T extends QueryBase> = Record<string, StringKey<keyof T['selectable']> | RawExpression | ((q: T) => Query)>;
 declare type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectAsArgs = SimpleSpread<FilterTuple<Args, SelectAsArg<T>>>> = AddQuerySelect<T, {
-    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : Arg extends keyof T['relations'] ? Arg : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['returns'] extends 'many' ? ArrayOfColumnsObjects<T['relations'][Arg]['model']['result']> : T['relations'][Arg]['options']['required'] extends true ? ColumnsObject<T['relations'][Arg]['model']['result']> : NullableColumn<ColumnsObject<T['relations'][Arg]['model']['result']>> : never : never;
+    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : Arg extends keyof T['relations'] ? Arg : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['returns'] extends 'many' ? ArrayOfColumnsObjects<T['relations'][Arg]['table']['result']> : T['relations'][Arg]['options']['required'] extends true ? ColumnsObject<T['relations'][Arg]['table']['result']> : NullableColumn<ColumnsObject<T['relations'][Arg]['table']['result']>> : never : never;
 } & {
     [K in keyof SelectAsArgs]: SelectAsArgs[K] extends keyof T['selectable'] ? T['selectable'][SelectAsArgs[K]]['column'] : SelectAsArgs[K] extends RawExpression ? SelectAsArgs[K]['__column'] : SelectAsArgs[K] extends (q: T) => Query ? SelectSubQueryResult<ReturnType<SelectAsArgs[K]>> : SelectAsArgs[K] extends ((q: T) => Query) | RawExpression ? SelectSubQueryResult<ReturnType<Exclude<SelectAsArgs[K], RawExpression>>> | Exclude<SelectAsArgs[K], (q: T) => Query>['__column'] : never;
 }>;
@@ -587,7 +588,7 @@ declare abstract class Where implements QueryBase {
     abstract shape: ColumnsShape;
     abstract relations: RelationsBase;
     abstract withData: WithDataBase;
-    abstract __model: Query;
+    abstract __table: Query;
     query: QueryData;
     table?: string;
     tableAlias?: string;
@@ -641,7 +642,7 @@ declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where i
     selectable: Q['selectable'];
     shape: Q['shape'];
     relations: Q['relations'];
-    __model: Query;
+    __table: Query;
     withData: {};
     constructor(q: QueryBase | string, shape: ColumnsShape);
     clone<T extends this>(this: T): T;
@@ -673,7 +674,7 @@ declare type JoinArgs<T extends QueryBase, Q extends Query = Query, R extends ke
     op: string,
     rightColumn: Selectable<T> | RawExpression
 ];
-declare type JoinResult<T extends Query, Args extends JoinArgs<T>, A extends Query | keyof T['relations'] = Args[0]> = AddQueryJoinedTable<T, A extends Query ? A : T['relations'] extends Record<string, Relation> ? A extends keyof T['relations'] ? T['relations'][A]['model'] : A extends keyof T['withData'] ? T['withData'][A] extends WithDataItem ? {
+declare type JoinResult<T extends Query, Args extends JoinArgs<T>, A extends Query | keyof T['relations'] = Args[0]> = AddQueryJoinedTable<T, A extends Query ? A : T['relations'] extends Record<string, Relation> ? A extends keyof T['relations'] ? T['relations'][A]['table'] : A extends keyof T['withData'] ? T['withData'][A] extends WithDataItem ? {
     table: T['withData'][A]['table'];
     tableAlias: undefined;
     result: T['withData'][A]['shape'];
@@ -691,11 +692,11 @@ declare type JoinCallback<T extends QueryBase, Arg extends JoinCallbackArg<T>> =
         };
     };
     shape: T['withData'][Arg]['shape'];
-    __model: Query;
+    __table: Query;
     relations: RelationsBase;
     withData: WithDataBase;
-} : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : never : never>) => OnQueryBuilder;
-declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['model'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
+} : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : never : never>) => OnQueryBuilder;
+declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
     table: T['withData'][Arg]['table'];
     tableAlias: undefined;
     result: T['withData'][Arg]['shape'];
@@ -986,13 +987,13 @@ declare type CreateBelongsToData<T extends Query, Key extends keyof T['relations
         connectOrCreate?: never;
     } | {
         create?: never;
-        connect: WhereArg<Rel['model']>;
+        connect: WhereArg<Rel['table']>;
         connectOrCreate?: never;
     } | {
         create?: never;
         connect?: never;
         connectOrCreate: {
-            where: WhereArg<Rel['model']>;
+            where: WhereArg<Rel['table']>;
             create: CreateData<Rel['nestedCreateQuery']>;
         };
     };
@@ -1004,13 +1005,13 @@ declare type CreateHasOneData<T extends Query, Key extends keyof T['relations'],
         connectOrCreate?: never;
     } | {
         create?: never;
-        connect: WhereArg<Rel['model']>;
+        connect: WhereArg<Rel['table']>;
         connectOrCreate?: never;
     } | {
         create?: never;
         connect?: never;
         connectOrCreate: {
-            where?: WhereArg<Rel['model']>;
+            where?: WhereArg<Rel['table']>;
             create?: CreateData<Rel['nestedCreateQuery']>;
         };
     };
@@ -1018,9 +1019,9 @@ declare type CreateHasOneData<T extends Query, Key extends keyof T['relations'],
 declare type CreateHasManyData<T extends Query, Key extends keyof T['relations'], Rel extends HasManyRelation | HasAndBelongsToManyRelation> = 'through' extends Rel['options'] ? {} : {
     [K in Key]?: {
         create?: CreateData<Rel['nestedCreateQuery']>[];
-        connect?: WhereArg<Rel['model']>[];
+        connect?: WhereArg<Rel['table']>[];
         connectOrCreate?: {
-            where: WhereArg<Rel['model']>;
+            where: WhereArg<Rel['table']>;
             create: CreateData<Rel['nestedCreateQuery']>;
         }[];
     };
@@ -1083,16 +1084,16 @@ declare type UpdateData<T extends Query> = {
 declare type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> = {
     disconnect: boolean;
 } | {
-    set: WhereArg<Rel['model']>;
+    set: WhereArg<Rel['table']>;
 } | {
     delete: boolean;
 } | {
-    update: UpdateData<Rel['model']>;
+    update: UpdateData<Rel['table']>;
 } | {
     create: CreateData<Rel['nestedCreateQuery']>;
 } | (QueryReturnsAll<T['returnType']> extends true ? never : {
     upsert: {
-        update: UpdateData<Rel['model']>;
+        update: UpdateData<Rel['table']>;
         create: CreateData<Rel['nestedCreateQuery']>;
     };
 });
@@ -1101,35 +1102,35 @@ declare type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> = {
 } | {
     delete: boolean;
 } | {
-    update: UpdateData<Rel['model']>;
+    update: UpdateData<Rel['table']>;
 } | (QueryReturnsAll<T['returnType']> extends true ? never : {
-    set: WhereArg<Rel['model']>;
+    set: WhereArg<Rel['table']>;
 } | {
     upsert: {
-        update: UpdateData<Rel['model']>;
+        update: UpdateData<Rel['table']>;
         create: CreateData<Rel['nestedCreateQuery']>;
     };
 } | {
     create: CreateData<Rel['nestedCreateQuery']>;
 });
 declare type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-    delete?: MaybeArray<WhereArg<Rel['model']>>;
+    disconnect?: MaybeArray<WhereArg<Rel['table']>>;
+    delete?: MaybeArray<WhereArg<Rel['table']>>;
     update?: {
-        where: MaybeArray<WhereArg<Rel['model']>>;
-        data: UpdateData<Rel['model']>;
+        where: MaybeArray<WhereArg<Rel['table']>>;
+        data: UpdateData<Rel['table']>;
     };
 } & (QueryReturnsAll<T['returnType']> extends true ? EmptyObject : {
-    set?: MaybeArray<WhereArg<Rel['model']>>;
+    set?: MaybeArray<WhereArg<Rel['table']>>;
     create?: CreateData<Rel['nestedCreateQuery']>[];
 });
 declare type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
-    disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-    set?: MaybeArray<WhereArg<Rel['model']>>;
-    delete?: MaybeArray<WhereArg<Rel['model']>>;
+    disconnect?: MaybeArray<WhereArg<Rel['table']>>;
+    set?: MaybeArray<WhereArg<Rel['table']>>;
+    delete?: MaybeArray<WhereArg<Rel['table']>>;
     update?: {
-        where: MaybeArray<WhereArg<Rel['model']>>;
-        data: UpdateData<Rel['model']>;
+        where: MaybeArray<WhereArg<Rel['table']>>;
+        data: UpdateData<Rel['table']>;
     };
     create?: CreateData<Rel['nestedCreateQuery']>[];
 };
@@ -1340,7 +1341,7 @@ interface QueryMethods extends Aggregate, Select, From, Join, With, Union, Json,
 }
 declare class QueryMethods {
     windows: EmptyObject;
-    __model: Query;
+    __table: Query;
     all<T extends Query>(this: T): SetQueryReturnsAll<T>;
     _all<T extends Query>(this: T): SetQueryReturnsAll<T>;
     take<T extends Query>(this: T): SetQueryReturnsOne<T>;
@@ -1545,7 +1546,7 @@ declare type QueryBase = {
     clone(): QueryBase;
     selectable: SelectableBase;
     shape: ColumnsShape;
-    __model: Query;
+    __table: Query;
     relations: RelationsBase;
     withData: WithDataBase;
 };
@@ -1926,6 +1927,48 @@ declare type JSONIntersection<Left extends JSONTypeAny, Right extends JSONTypeAn
 };
 declare const intersection: <Left extends JSONTypeAny, Right extends JSONTypeAny>(left: Left, right: Right) => JSONIntersection<Left, Right>;
 
+declare type JSONTypeAny = JSONType<any>;
+declare type DeepPartial<T extends JSONTypeAny> = ReturnType<JSONTypeAny['deepPartial']> extends ReturnType<T['deepPartial']> ? T : ReturnType<T['deepPartial']>;
+declare type JSONTypeData = ColumnData & {
+    optional?: true;
+    nullable?: true;
+    isDeepPartial?: true;
+    isNonEmpty?: true;
+};
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type JSONType<Type, DataType extends string = string> = {
+    type: Type;
+    data: JSONTypeData;
+    dataType: DataType;
+    chain: ColumnChain;
+    toCode(t: string): Code;
+    optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
+    required<T extends JSONTypeAny>(this: T): JSONRequired<T>;
+    nullable<T extends JSONTypeAny>(this: T): JSONNullable<T>;
+    notNullable<T extends JSONTypeAny>(this: T): JSONNotNullable<T>;
+    nullish<T extends JSONTypeAny>(this: T): JSONNullish<T>;
+    notNullish<T extends JSONTypeAny>(this: T): JSONNotNullish<T>;
+    deepPartial(): JSONTypeAny;
+    transform<T extends JSONTypeAny, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): JSONType<Transformed extends PromiseLike<unknown> ? Awaited<Transformed> : Transformed, T['dataType']>;
+    to<T extends JSONTypeAny, ToType extends JSONTypeAny>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
+    refine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
+        type: RefinedOutput;
+    };
+    superRefine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
+        type: RefinedOutput;
+    };
+    and<A extends JSONTypeAny, B extends JSONTypeAny>(this: A, type: B): JSONIntersection<A, B>;
+    or<T extends JSONTypeAny, U extends [JSONTypeAny, ...JSONTypeAny[]]>(this: T, ...types: U): T | U[number];
+    default<T extends JSONTypeAny>(this: T, value: T['type'] | (() => T['type'])): JSONNotNullish<T>;
+    array<T extends JSONTypeAny>(this: T): JSONArray<T>;
+};
+declare const toCode: (type: JSONTypeAny, t: string, code: Code) => Code;
+declare type BaseTypeProps<T extends JSONTypeAny> = Omit<JSONType<T['type']>, 'dataType'>;
+declare type OwnTypeProps<T extends JSONTypeAny> = Omit<T, keyof BaseTypeProps<T>> & {
+    [k in keyof BaseTypeProps<T>]?: BaseTypeProps<T>[k];
+};
+declare const constructType: <T extends JSONTypeAny>(type: OwnTypeProps<T>) => T;
+
 declare function min<T extends {
     data: {
         min?: number;
@@ -1962,28 +2005,32 @@ declare function size<T extends {
         size: Value;
     };
 };
-declare function nonempty<T extends {
+declare type NonEmptyBase = {
     data: {
         min?: number;
+        isNonEmpty?: true;
     };
-}>(this: T): Omit<T, "data"> & {
-    data: Omit<T["data"], "min"> & {
-        min: number;
+};
+declare type NonEmptyResult<T extends NonEmptyBase> = Omit<T, 'data'> & {
+    data: Omit<T['data'], 'min'> & {
+        min: 1;
+        isNonEmpty: true;
     };
 };
+declare function nonEmpty<T extends NonEmptyBase>(this: T): NonEmptyResult<T>;
 declare type ArrayMethods$1 = typeof arrayMethods;
 declare const arrayMethods: {
     min: typeof min;
     max: typeof max;
     length: typeof length;
-    nonempty: typeof nonempty;
+    nonEmpty: typeof nonEmpty;
 };
 declare type SetMethods = typeof setMethods;
 declare const setMethods: {
     min: typeof min;
     max: typeof max;
     size: typeof size;
-    nonempty: typeof nonempty;
+    nonEmpty: typeof nonEmpty;
 };
 declare const numberTypeMethods: {
     lt<T extends {
@@ -2126,303 +2173,179 @@ declare const dateTypeMethods: {
 };
 
 declare type ArrayCardinality = 'many' | 'atLeastOne';
-declare type arrayOutputType<T extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> = Cardinality extends 'atLeastOne' ? [T['type'], ...T['type'][]] : T['type'][];
-interface JSONArray<Type extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> extends JSONType<arrayOutputType<Type, Cardinality>, 'array'>, ArrayMethods$1 {
+declare type ArrayOutputType<T extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> = Cardinality extends 'atLeastOne' ? [T['type'], ...T['type'][]] : T['type'][];
+interface JSONArray<Type extends JSONTypeAny, Cardinality extends ArrayCardinality = 'many'> extends JSONType<ArrayOutputType<Type, Cardinality>, 'array'>, ArrayMethods$1 {
     data: JSONTypeData & {
         min?: number;
         max?: number;
         length?: number;
     };
     element: Type;
-    deepPartial(): JSONArray<DeepPartial<Type>, Cardinality>;
-    nonEmpty(this: JSONArray<Type>): JSONArray<Type, 'atLeastOne'> & {
-        data: {
-            min: 1;
-        };
-    };
+    deepPartial<T extends JSONArray<Type>>(this: T): JSONArray<DeepPartial<Type>, Cardinality>;
 }
 declare const array: <Type extends JSONTypeAny>(element: Type) => JSONArray<Type, "many">;
 
-declare type JSONTypeAny = JSONType<any, string>;
-declare type DeepPartial<T extends JSONTypeAny> = ReturnType<JSONTypeAny['deepPartial']> extends ReturnType<T['deepPartial']> ? T : ReturnType<T['deepPartial']>;
-declare type JSONTypeData = ColumnData & {
-    optional?: true;
-    nullable?: true;
+declare type JSONObjectShape = Record<string, JSONTypeAny>;
+declare type UnknownKeysParam = 'passthrough' | 'strict' | 'strip';
+declare type FullyPartial<T extends JSONObjectShape> = {
+    [K in keyof T]: JSONOptional<T[K]>;
 };
-declare type Primitive = string | number | bigint | boolean | null | undefined;
-declare type JSONType<Type, DataType extends string = string> = {
-    type: Type;
-    data: JSONTypeData;
-    dataType: DataType;
-    chain: (['transform', (input: unknown, ctx: ValidationContext) => unknown] | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ['refine', (input: unknown) => unknown] | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown])[];
-    optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
-    required<T extends JSONTypeAny>(this: T): JSONRequired<T>;
-    nullable<T extends JSONTypeAny>(this: T): JSONNullable<T>;
-    notNullable<T extends JSONTypeAny>(this: T): JSONNotNullable<T>;
-    nullish<T extends JSONTypeAny>(this: T): JSONNullish<T>;
-    notNullish<T extends JSONTypeAny>(this: T): JSONNotNullish<T>;
-    deepPartial(): JSONTypeAny;
-    transform<T extends JSONTypeAny, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): JSONType<Transformed extends PromiseLike<unknown> ? Awaited<Transformed> : Transformed, T['dataType']>;
-    to<T extends JSONTypeAny, ToType extends JSONTypeAny>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
-    refine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
-        type: RefinedOutput;
+declare type PartiallyPartial<T extends JSONObjectShape, P extends keyof T> = {
+    [K in keyof T]: K extends P ? JSONOptional<T[K]> : T[K];
+};
+declare type identity<T> = T;
+declare type flatten<T extends object> = identity<{
+    [k in keyof T]: T[k];
+}>;
+declare type optionalKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? k : never;
+}[keyof T];
+declare type requiredKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? never : k;
+}[keyof T];
+declare type addQuestionMarks<T extends object> = Partial<Pick<T, optionalKeys<T>>> & Pick<T, requiredKeys<T>>;
+declare type baseObjectOutputType<Shape extends JSONObjectShape> = flatten<addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]['type'];
+}>>;
+declare type ObjectOutputType<Shape extends JSONObjectShape, Catchall extends JSONTypeAny> = JSONTypeAny extends Catchall ? baseObjectOutputType<Shape> : flatten<baseObjectOutputType<Shape> & {
+    [k: string]: Catchall['type'];
+}>;
+declare type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+declare type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
+declare type Except<ObjectType, KeysType extends keyof ObjectType> = {
+    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+};
+declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+interface JSONObject<T extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = 'strip', Catchall extends JSONTypeAny = JSONTypeAny, Output = ObjectOutputType<T, Catchall>> extends JSONType<Output, 'object'> {
+    shape: T;
+    unknownKeys: UnknownKeys;
+    catchAllType: Catchall;
+    extend<S extends JSONObjectShape>(shape: S): JSONObject<Merge<T, S>, UnknownKeys, Catchall>;
+    merge<S extends JSONObjectShape, U extends UnknownKeysParam, C extends JSONTypeAny>(obj: JSONObject<S, U, C>): JSONObject<Merge<T, S>, U, C>;
+    pick<K extends keyof T>(...arr: K[]): JSONObject<Pick<T, K>, UnknownKeys, Catchall>;
+    omit<K extends keyof T>(...arr: K[]): JSONObject<Omit<T, K>, UnknownKeys, Catchall>;
+    partial(): JSONObject<FullyPartial<T>, UnknownKeys, Catchall>;
+    partial<P extends keyof T>(...arr: P[]): JSONObject<PartiallyPartial<T, P>, UnknownKeys, Catchall>;
+    deepPartial(): JSONObject<{
+        [k in keyof T]: JSONOptional<DeepPartial<T[k]>>;
+    }, UnknownKeys, Catchall>;
+    passthrough(): JSONObject<T, 'passthrough', Catchall>;
+    strict(): JSONObject<T, 'strict', Catchall>;
+    strip(): JSONObject<T, 'strip', Catchall>;
+    catchAll<C extends JSONTypeAny>(type: C): JSONObject<T, UnknownKeys, C>;
+}
+declare const object: <T extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T) => JSONObject<T, UnknownKeys, Catchall, ObjectOutputType<T, Catchall>>;
+
+interface JSONLiteral<T extends Primitive> extends JSONType<T, 'literal'> {
+    value: Primitive;
+}
+declare const literal: <T extends Primitive>(value: T) => JSONLiteral<T>;
+
+interface JSONDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends JSONDiscriminatedObject<Discriminator, DiscriminatorValue>> extends JSONType<Option['type'], 'discriminatedUnion'> {
+    discriminator: Discriminator;
+    discriminatorValue: DiscriminatorValue;
+    options: Map<DiscriminatorValue, Option>;
+    _option: Option;
+}
+declare type JSONDiscriminatedObject<Discriminator extends string, DiscriminatorValue extends Primitive> = JSONObject<{
+    [K in Discriminator]: JSONLiteral<DiscriminatorValue>;
+} & JSONObjectShape, any>;
+declare const discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends Primitive, Types extends [JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
+
+interface JSONEnum<U extends string = string, T extends [U, ...U[]] = [U]> extends JSONType<T[number], 'enum'> {
+    enum: {
+        [k in T[number]]: k;
     };
-    superRefine<T extends JSONTypeAny, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
-        type: RefinedOutput;
+    options: T;
+}
+declare const arrayToEnum: <U extends string, T extends [U, ...U[]]>(items: T) => { [k in T[number]]: k; };
+declare const enumType: <U extends string, T extends [U, ...U[]]>(options: T) => JSONEnum<U, T>;
+
+interface JSONInstanceOf<T extends Class> extends JSONType<T, 'instanceOf'> {
+    class: T;
+}
+declare type Class = new (...args: any[]) => any;
+declare const instanceOf: <T extends Class>(cls: T) => JSONInstanceOf<T>;
+
+interface JSONLazy<T extends JSONTypeAny> extends JSONType<T['type'], 'lazy'> {
+    data: JSONTypeData & {
+        isDeepPartial?: boolean;
     };
-    and<A extends JSONTypeAny, B extends JSONTypeAny>(this: A, type: B): JSONIntersection<A, B>;
-    or<T extends JSONTypeAny, U extends [JSONTypeAny, ...JSONTypeAny[]]>(this: T, ...types: U): T | U[number];
-    default<T extends JSONTypeAny>(this: T, value: T['type'] | (() => T['type'])): JSONNotNullish<T>;
-    array<T extends JSONTypeAny>(this: T): JSONArray<T>;
-};
-declare type BaseTypeProps<T extends JSONTypeAny> = Omit<JSONType<T['type'], string>, 'dataType'>;
-declare type OwnTypeProps<T extends JSONTypeAny> = Omit<T, keyof BaseTypeProps<T>> & {
-    [k in keyof BaseTypeProps<T>]?: BaseTypeProps<T>[k];
+    typeCache?: T;
+    getter(): T;
+    deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
+}
+declare const lazy: <T extends JSONTypeAny>(fn: () => T) => JSONLazy<T>;
+
+interface JSONMap<Key extends JSONTypeAny, Value extends JSONTypeAny> extends JSONType<Map<Key['type'], Value['type']>, 'map'> {
+    data: JSONTypeData & {
+        isDeepPartial?: boolean;
+    };
+    keyType: Key;
+    valueType: Value;
+    deepPartial(): JSONMap<ReturnType<Key['deepPartial']>, ReturnType<Value['deepPartial']>>;
+}
+declare const map: <Key extends JSONTypeAny, Value extends JSONTypeAny>(keyType: Key, valueType: Value) => JSONMap<Key, Value>;
+
+interface JSONNativeEnum<T extends EnumLike> extends JSONType<T[keyof T], 'nativeEnum'> {
+    dataType: 'nativeEnum';
+    enum: T;
+    options: (number | string)[];
+}
+declare type EnumLike = {
+    [k: string]: string | number;
+    [nu: number]: string;
 };
-declare const constructType: <T extends JSONTypeAny>(type: OwnTypeProps<T>) => T;
+declare const getValidEnumValues: (obj: EnumLike) => (string | number)[];
+declare const nativeEnum: <T extends EnumLike>(givenEnum: T) => JSONNativeEnum<T>;
 
-declare type ColumnsShape = Record<string, ColumnType>;
-declare type ColumnShapeOutput<Shape extends ColumnsShape> = {
-    [K in keyof Shape]: ColumnOutput<Shape[K]>;
+declare type BaseNumberData = ColumnData & {
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    multipleOf?: number;
+    int?: boolean;
 };
-declare type OptionalColumnsForInput<Shape extends ColumnsShape> = {
-    [K in keyof Shape]: SomeIsTrue<[
-        Shape[K]['isNullable'],
-        Shape[K]['hasDefault']
-    ]> extends true ? K : never;
-}[keyof Shape];
-declare type ColumnShapeInput<Shape extends ColumnsShape> = SetOptional<{
-    [K in keyof Shape]: ColumnInput<Shape[K]>;
-}, OptionalColumnsForInput<Shape>>;
-declare class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<{
-    [K in keyof Shape]: Shape[K]['type'];
-}, typeof Operators.any> {
-    shape: Shape;
-    dataType: string;
+declare type NumberColumn = ColumnType<number>;
+declare type NumberColumnData = BaseNumberData;
+declare type NumberMethods = typeof numberTypeMethods;
+interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
+}
+declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
+    data: BaseNumberData;
     operators: {
-        equals: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+        lt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-        not: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+        lte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        gt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        gte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-    };
-    constructor(shape: Shape);
-}
-declare class ArrayOfColumnsObjects<Shape extends ColumnsShape> extends ColumnType<{
-    [K in keyof Shape]: Shape[K]['type'];
-}[], typeof Operators.any> {
-    shape: Shape;
-    dataType: string;
-    operators: {
-        equals: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+        between: ((key: string, value: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>], values: unknown[]) => string) & {
+            type: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>];
         };
-        not: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+        equals: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        not: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
-        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
         };
     };
-    constructor(shape: Shape);
 }
-declare abstract class PluckResultColumnType<C extends ColumnType> extends ColumnType<C['type'][], typeof Operators.any> {
-}
-declare type SinglePrimaryKey<Shape extends ColumnsShape> = StringKey<{
-    [K in keyof Shape]: Shape[K]['isPrimaryKey'] extends true ? [
-        {
-            [S in keyof Shape]: Shape[S]['isPrimaryKey'] extends true ? S extends K ? never : S : never;
-        }[keyof Shape]
-    ] extends [never] ? K : never : never;
-}[keyof Shape]>;
-
-declare type ColumnOutput<T extends ColumnType> = T['type'];
-declare type ColumnInput<T extends ColumnType> = T['inputType'];
-declare type NullableColumn<T extends ColumnType> = Omit<T, 'type' | 'inputType' | 'operators'> & {
-    type: T['type'] | null;
-    inputType: T['inputType'] | null;
-    isNullable: true;
-    operators: Omit<T['operators'], 'equals' | 'not'> & {
-        equals: Operator<T['type'] | null>;
-        not: Operator<T['type'] | null>;
-    };
-};
-declare type AnyColumnType = ColumnType<any, Record<string, Operator<any>>>;
-declare type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType | {};
-declare type ColumnTypesBase = Record<string, AnyColumnTypeCreator>;
-declare type ValidationContext = any;
-declare type ColumnData = {
-    default?: unknown;
-    validationDefault?: unknown;
-    index?: Omit<SingleColumnIndexOptions, 'column'>;
-    comment?: string;
-    collate?: string;
-    compression?: string;
-    foreignKey?: ForeignKey<string, string[]>;
-    modifyQuery?: (q: Query) => void;
-    as?: ColumnType;
-};
-declare type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
-declare type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
-declare type ForeignKey<Table extends string, Columns extends string[]> = ({
-    fn(): new () => {
-        table: Table;
-    };
-} | {
-    table: Table;
-}) & {
-    columns: Columns;
-} & ForeignKeyOptions;
-declare type DropMode = 'CASCADE' | 'RESTRICT';
-declare type ForeignKeyOptions = {
-    name?: string;
-    match?: ForeignKeyMatch;
-    onUpdate?: ForeignKeyAction;
-    onDelete?: ForeignKeyAction;
-    dropMode?: DropMode;
-};
-declare type IndexColumnOptions = {
-    column: string;
-    expression?: number | string;
-    collate?: string;
-    operator?: string;
-    order?: string;
-};
-declare type IndexOptions = {
-    name?: string;
-    unique?: boolean;
-    using?: string;
-    include?: MaybeArray<string>;
-    with?: string;
-    tablespace?: string;
-    where?: string;
-    dropMode?: 'CASCADE' | 'RESTRICT';
-};
-declare type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
-declare type ForeignKeyModel = new () => {
-    table: string;
-};
-declare type ForeignKeyModelWithColumns = new () => {
-    table: string;
-    columns: {
-        shape: ColumnsShape;
-    };
-};
-declare type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> = StringKey<keyof InstanceType<Model>['columns']['shape']>;
-declare abstract class ColumnType<Type = unknown, Ops extends Operators = Operators, InputType = Type> {
-    abstract dataType: string;
-    abstract operators: Ops;
-    type: Type;
-    inputType: InputType;
-    data: ColumnData;
-    isPrimaryKey: boolean;
-    isHidden: boolean;
-    isNullable: boolean;
-    hasDefault: boolean;
-    encodeFn?: (input: any) => unknown;
-    parseFn?: (input: unknown) => unknown;
-    parseItem?: (input: string) => unknown;
-    chain: (["transform", (input: unknown, ctx: ValidationContext) => unknown] | ["to", (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ["refine", (input: unknown) => unknown] | ["superRefine", (input: unknown, ctx: ValidationContext) => unknown])[];
-    primaryKey<T extends ColumnType>(this: T): T & {
-        isPrimaryKey: true;
-    };
-    foreignKey<T extends ColumnType, Model extends ForeignKeyModelWithColumns, Column extends ColumnNameOfModel<Model>>(this: T, fn: () => Model, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
-        foreignKeyData: ForeignKey<InstanceType<Model>['table'], [Column]>;
-    };
-    foreignKey<T extends ColumnType, Table extends string, Column extends string>(this: T, table: Table, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
-        foreignKeyData: ForeignKey<Table, [Column]>;
-    };
-    hidden<T extends ColumnType>(this: T): T & {
-        isHidden: true;
-    };
-    nullable<T extends ColumnType>(this: T): NullableColumn<T>;
-    encode<T extends ColumnType, Input>(this: T, fn: (input: Input) => unknown): Omit<T, 'inputType'> & {
-        inputType: Input;
-    };
-    parse<T extends ColumnType, Output>(this: T, fn: (input: T['type']) => Output): Omit<T, 'type'> & {
-        type: Output;
-    };
-    as<T extends ColumnType, C extends ColumnType<T['type'], Operators, T['inputType']>>(this: T, column: C): C;
-    toSQL(): string;
-    default<T extends ColumnType>(this: T, value: T['type'] | RawExpression): T & {
-        hasDefault: true;
-    };
-    index<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column'>): T;
-    unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
-    comment<T extends ColumnType>(this: T, comment: string): T;
-    validationDefault<T extends ColumnType>(this: T, value: T['type']): T;
-    compression<T extends ColumnType>(this: T, compression: string): T;
-    collate<T extends ColumnType>(this: T, collate: string): T;
-    modifyQuery<T extends ColumnType>(this: T, cb: (q: Query) => void): T;
-    transform<T extends ColumnType, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): Omit<T, 'type'> & {
-        type: Transformed;
-    };
-    to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
-    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
-        type: RefinedOutput;
-    };
-    superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
-        type: RefinedOutput;
-    };
-}
-
-declare type BaseNumberData = ColumnData & {
-    lt?: number;
-    lte?: number;
-    gt?: number;
-    gte?: number;
-    multipleOf?: number;
-    int?: boolean;
-};
-declare type NumberColumn = ColumnType<number>;
-declare type NumberColumnData = BaseNumberData;
-declare type NumberMethods = typeof numberTypeMethods;
-interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
-}
-declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
-    data: BaseNumberData;
-    operators: {
-        lt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        lte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        gt: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        gte: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        between: ((key: string, value: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>], values: unknown[]) => string) & {
-            type: [number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>];
-        };
-        equals: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        not: ((key: string, value: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: number | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
-            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
-        };
-        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[], values: unknown[]) => string) & {
-            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | number[];
-        };
-    };
-}
-declare abstract class IntegerBaseColumn extends NumberBaseColumn {
-    data: BaseNumberData;
+declare abstract class IntegerBaseColumn extends NumberBaseColumn {
+    data: BaseNumberData;
 }
 declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
     data: {};
@@ -2496,41 +2419,50 @@ declare class DecimalBaseColumn<Precision extends number | undefined = undefined
     };
     dataType: "decimal";
     constructor(precision?: Precision, scale?: Scale);
+    toCode(t: string): Code;
     toSQL(): string;
 }
 declare class SmallIntColumn extends IntegerBaseColumn {
     dataType: "smallint";
     parseItem: typeof parseInt;
+    toCode(t: string): Code;
 }
 declare class IntegerColumn extends IntegerBaseColumn {
     dataType: "integer";
     parseItem: typeof parseInt;
+    toCode(t: string): Code;
 }
 declare class BigIntColumn extends NumberAsStringBaseColumn {
     dataType: "bigint";
+    toCode(t: string): Code;
 }
 declare class DecimalColumn<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined> extends DecimalBaseColumn<Precision, Scale> {
 }
 declare class RealColumn extends NumberBaseColumn {
     dataType: "real";
     parseItem: typeof parseFloat;
+    toCode(t: string): Code;
 }
 declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
     dataType: "double precision";
+    toCode(t: string): Code;
 }
 declare class SmallSerialColumn extends IntegerBaseColumn {
     dataType: "smallserial";
     parseItem: typeof parseInt;
     hasDefault: true;
+    toCode(t: string): Code;
 }
 declare class SerialColumn extends IntegerBaseColumn {
     dataType: "serial";
     parseItem: typeof parseInt;
     hasDefault: true;
+    toCode(t: string): Code;
 }
 declare class BigSerialColumn extends NumberAsStringBaseColumn {
     dataType: "bigserial";
     hasDefault: true;
+    toCode(t: string): Code;
 }
 
 declare type BaseStringData = ColumnData & {
@@ -2545,6 +2477,7 @@ declare type BaseStringData = ColumnData & {
     startsWith?: string;
     endsWith?: string;
     trim?: boolean;
+    isNonEmpty?: true;
 };
 declare type StringColumn = ColumnType<string>;
 declare type TextColumnData = BaseStringData;
@@ -2649,15 +2582,7 @@ declare const textMethods: {
             length: Value_5;
         };
     };
-    nonempty: <T_11 extends {
-        data: {
-            min?: number | undefined;
-        };
-    }>(this: T_11) => Omit<T_11, "data"> & {
-        data: Omit<T_11["data"], "min"> & {
-            min: number;
-        };
-    };
+    nonEmpty: <T_11 extends NonEmptyBase>(this: T_11) => NonEmptyResult<T_11>;
 };
 interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, TextMethods {
 }
@@ -2698,16 +2623,18 @@ declare abstract class TextBaseColumn extends ColumnType<string, typeof Operator
 }
 declare abstract class LimitedTextBaseColumn<Limit extends number | undefined = undefined> extends TextBaseColumn {
     data: TextColumnData & {
-        max: Limit;
+        arg: Limit;
     };
     constructor(limit?: Limit);
     toSQL(): string;
 }
 declare class VarCharColumn<Limit extends number | undefined = undefined> extends LimitedTextBaseColumn<Limit> {
     dataType: "varchar";
+    toCode(t: string): Code;
 }
 declare class CharColumn<Limit extends number | undefined = undefined> extends LimitedTextBaseColumn<Limit> {
     dataType: "char";
+    toCode(t: string): Code;
 }
 declare class TextColumn extends TextBaseColumn {
     dataType: "text";
@@ -2743,6 +2670,7 @@ declare class TextColumn extends TextBaseColumn {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
     dataType: "bytea";
@@ -2778,6 +2706,7 @@ declare class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class PointColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "point";
@@ -2813,9 +2742,10 @@ declare class PointColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class LineColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "line";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -2848,9 +2778,10 @@ declare class LineColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "lseg";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -2883,9 +2814,10 @@ declare class LsegColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "box";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -2918,9 +2850,10 @@ declare class BoxColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class PathColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "path";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -2953,9 +2886,10 @@ declare class PathColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "polygon";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -2988,9 +2922,10 @@ declare class PolygonColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class CircleColumn extends ColumnType<string, typeof Operators.text> {
-    dataType: "point";
+    dataType: "circle";
     operators: {
         contains: ((key: string, value: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
             type: string | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
@@ -3023,10 +2958,14 @@ declare class CircleColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class MoneyColumn extends NumberBaseColumn {
     dataType: "money";
-    parseFn: (input: unknown) => number;
+    toCode(t: string): Code;
+    parseFn: ((input: unknown) => number) & {
+        hideFromCode: boolean;
+    };
 }
 declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "cidr";
@@ -3062,6 +3001,7 @@ declare class CidrColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class InetColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "inet";
@@ -3097,6 +3037,7 @@ declare class InetColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr";
@@ -3132,6 +3073,7 @@ declare class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
     dataType: "macaddr8";
@@ -3167,6 +3109,7 @@ declare class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class BitColumn<Length extends number> extends ColumnType<string, typeof Operators.text> {
     dataType: "bit";
@@ -3206,6 +3149,7 @@ declare class BitColumn<Length extends number> extends ColumnType<string, typeof
         length: Length;
     };
     constructor(length: Length);
+    toCode(t: string): Code;
     toSQL(): string;
 }
 declare class BitVaryingColumn<Length extends number | undefined = undefined> extends ColumnType<string, typeof Operators.text> {
@@ -3245,7 +3189,8 @@ declare class BitVaryingColumn<Length extends number | undefined = undefined> ex
     data: ColumnData & {
         length: Length;
     };
-    constructor(length: Length);
+    constructor(length?: Length);
+    toCode(t: string): Code;
     toSQL(): string;
 }
 declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
@@ -3282,6 +3227,7 @@ declare class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "tsquery";
@@ -3317,6 +3263,7 @@ declare class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "uuid";
@@ -3352,6 +3299,7 @@ declare class UUIDColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 declare class XMLColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "xml";
@@ -3387,6 +3335,7 @@ declare class XMLColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
 }
 
 declare type DateColumnData = ColumnData & {
@@ -3434,6 +3383,7 @@ declare abstract class DateBaseColumn extends ColumnType<string, typeof Operator
 }
 declare class DateColumn extends DateBaseColumn {
     dataType: "date";
+    toCode(t: string): Code;
 }
 declare type DateTimeColumnData = DateColumnData & {
     precision?: number;
@@ -3451,17 +3401,21 @@ declare abstract class DateTimeWithTimeZoneBaseClass<Precision extends number |
 }
 declare class TimestampColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
     dataType: "timestamp";
+    toCode(t: string): Code;
 }
 declare class TimestampWithTimeZoneColumn<Precision extends number | undefined = undefined> extends DateTimeWithTimeZoneBaseClass<Precision> {
     dataType: "timestamp with time zone";
     baseDataType: "timestamp";
+    toCode(t: string): Code;
 }
 declare class TimeColumn<Precision extends number | undefined = undefined> extends DateTimeBaseClass<Precision> {
     dataType: "time";
+    toCode(t: string): Code;
 }
 declare class TimeWithTimeZoneColumn<Precision extends number | undefined = undefined> extends DateTimeWithTimeZoneBaseClass<Precision> {
     dataType: "time with time zone";
     baseDataType: "time";
+    toCode(t: string): Code;
 }
 declare type TimeInterval = {
     years?: number;
@@ -3473,7 +3427,7 @@ declare type TimeInterval = {
 };
 declare class IntervalColumn<Fields extends string | undefined = undefined, Precision extends number | undefined = undefined> extends ColumnType<TimeInterval, typeof Operators.date> {
     dataType: "interval";
-    data: DateTimeColumnData & {
+    data: ColumnData & {
         fields: Fields;
         precision: Precision;
     };
@@ -3507,199 +3461,52 @@ declare class IntervalColumn<Fields extends string | undefined = undefined, Prec
         };
     };
     constructor(fields?: Fields, precision?: Precision);
+    toCode(t: string): Code;
     toSQL(): string;
 }
 
-declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean> {
-    dataType: "boolean";
-    operators: {
-        equals: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+declare type JSONAny = JSONTypeAny & {
+    dataType: 'any';
+};
+declare type JSONBigInt = JSONType<bigint, 'bigint'> & {
+    data: BaseNumberData;
+} & typeof bigIntMethods;
+declare const bigIntMethods: {
+    toCode(this: JSONTypeAny, t: string): Code;
+    lt<T extends {
+        data: {
+            lt?: number | undefined;
         };
-        not: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+    }, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
+        data: Omit<T["data"], "lt"> & {
+            lt: Value;
         };
-        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
-            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+    };
+    lte<T_1 extends {
+        data: {
+            lte?: number | undefined;
         };
-        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
-            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+    }, Value_1 extends number>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
+        data: Omit<T_1["data"], "lte"> & {
+            lte: Value_1;
         };
     };
-    parseItem: (input: string) => boolean;
-}
-
-declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]> extends ColumnType<T[number], typeof Operators.any> {
-    enumName: string;
-    options: T;
-    operators: {
-        equals: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+    max<T_2 extends {
+        data: {
+            lte?: number | undefined;
         };
-        not: ((key: string, value: any, values: unknown[]) => string) & {
-            type: any;
+    }, Value_2 extends number>(this: T_2, value: Value_2): Omit<T_2, "data"> & {
+        data: Omit<T_2["data"], "lte"> & {
+            lte: Value_2;
         };
-        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+    };
+    gt<T_3 extends {
+        data: {
+            gt?: number | undefined;
         };
-        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
-            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
-        };
-    };
-    dataType: string;
-    constructor(enumName: string, options: T);
-    toSql(): string;
-}
-
-declare type JSONObjectShape = Record<string, JSONTypeAny>;
-declare type UnknownKeysParam = 'passthrough' | 'strict' | 'strip';
-declare type FullyPartial<T extends JSONObjectShape> = {
-    [K in keyof T]: JSONOptional<T[K]>;
-};
-declare type PartiallyPartial<T extends JSONObjectShape, P extends keyof T> = {
-    [K in keyof T]: K extends P ? JSONOptional<T[K]> : T[K];
-};
-declare type identity<T> = T;
-declare type flatten<T extends object> = identity<{
-    [k in keyof T]: T[k];
-}>;
-declare type optionalKeys<T extends object> = {
-    [k in keyof T]: undefined extends T[k] ? k : never;
-}[keyof T];
-declare type requiredKeys<T extends object> = {
-    [k in keyof T]: undefined extends T[k] ? never : k;
-}[keyof T];
-declare type addQuestionMarks<T extends object> = Partial<Pick<T, optionalKeys<T>>> & Pick<T, requiredKeys<T>>;
-declare type baseObjectOutputType<Shape extends JSONObjectShape> = flatten<addQuestionMarks<{
-    [k in keyof Shape]: Shape[k]['type'];
-}>>;
-declare type objectOutputType<Shape extends JSONObjectShape, Catchall extends JSONTypeAny> = JSONTypeAny extends Catchall ? baseObjectOutputType<Shape> : flatten<baseObjectOutputType<Shape> & {
-    [k: string]: Catchall['type'];
-}>;
-declare type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
-declare type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
-declare type Except<ObjectType, KeysType extends keyof ObjectType> = {
-    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-};
-declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
-interface JSONObject<T extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = 'strip', Catchall extends JSONTypeAny = JSONTypeAny, Output = objectOutputType<T, Catchall>> extends JSONType<Output, 'object'> {
-    shape: T;
-    unknownKeys: UnknownKeys;
-    catchAllType: Catchall;
-    extend<S extends JSONObjectShape>(shape: S): JSONObject<Merge<T, S>, UnknownKeys, Catchall>;
-    merge<S extends JSONObjectShape, U extends UnknownKeysParam, C extends JSONTypeAny>(obj: JSONObject<S, U, C>): JSONObject<Merge<T, S>, U, C>;
-    pick<K extends keyof T>(...arr: K[]): JSONObject<Pick<T, K>, UnknownKeys, Catchall>;
-    omit<K extends keyof T>(...arr: K[]): JSONObject<Omit<T, K>, UnknownKeys, Catchall>;
-    partial(): JSONObject<FullyPartial<T>, UnknownKeys, Catchall>;
-    partial<P extends keyof T>(...arr: P[]): JSONObject<PartiallyPartial<T, P>, UnknownKeys, Catchall>;
-    deepPartial(): JSONObject<{
-        [k in keyof T]: JSONOptional<DeepPartial<T[k]>>;
-    }, UnknownKeys, Catchall>;
-    passthrough(): JSONObject<T, 'passthrough', Catchall>;
-    strict(): JSONObject<T, 'strict', Catchall>;
-    strip(): JSONObject<T, 'strip', Catchall>;
-    catchAll<C extends JSONTypeAny>(type: C): JSONObject<T, UnknownKeys, C>;
-}
-declare const object: <T extends JSONObjectShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends JSONTypeAny = JSONTypeAny>(shape: T) => JSONObject<T, UnknownKeys, Catchall, objectOutputType<T, Catchall>>;
-
-interface JSONNativeEnum<T extends EnumLike> extends JSONType<T[keyof T], 'nativeEnum'> {
-    dataType: 'nativeEnum';
-    enum: T;
-    options: (number | string)[];
-}
-declare type EnumLike = {
-    [k: string]: string | number;
-    [nu: number]: string;
-};
-declare const getValidEnumValues: (obj: EnumLike) => (string | number)[];
-declare const nativeEnum: <T extends EnumLike>(givenEnum: T) => JSONNativeEnum<T>;
-
-interface JSONMap<Key extends JSONTypeAny, Value extends JSONTypeAny> extends JSONType<Map<Key['type'], Value['type']>, 'map'> {
-    keyType: Key;
-    valueType: Value;
-    deepPartial(): JSONMap<ReturnType<Key['deepPartial']>, ReturnType<Value['deepPartial']>>;
-}
-declare const map: <Key extends JSONTypeAny, Value extends JSONTypeAny>(keyType: Key, valueType: Value) => JSONMap<Key, Value>;
-
-interface JSONLiteral<T extends Primitive> extends JSONType<T, 'literal'> {
-    value: Primitive;
-}
-declare const literal: <T extends Primitive>(value: T) => JSONLiteral<T>;
-
-interface JSONLazy<T extends JSONTypeAny> extends JSONType<T['type'], 'lazy'> {
-    typeCache?: T;
-    getter(): T;
-    deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
-}
-declare const lazy: <T extends JSONTypeAny>(fn: () => T) => JSONLazy<T>;
-
-interface JSONInstanceOf<T extends Class> extends JSONType<T, 'instanceOf'> {
-    class: T;
-}
-declare type Class = new (...args: any[]) => any;
-declare const instanceOf: <T extends Class>(cls: T) => JSONInstanceOf<T>;
-
-interface JSONEnum<U extends string = string, T extends [U, ...U[]] = [U]> extends JSONType<T[number], 'enum'> {
-    enum: {
-        [k in T[number]]: k;
-    };
-    options: T;
-}
-declare const arrayToEnum: <U extends string, T extends [U, ...U[]]>(items: T) => { [k in T[number]]: k; };
-declare const enumType: <U extends string, T extends [U, ...U[]]>(options: T) => JSONEnum<U, T>;
-
-interface JSONDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends JSONDiscriminatedObject<Discriminator, DiscriminatorValue>> extends JSONType<Option['type'], 'discriminatedUnion'> {
-    discriminator: Discriminator;
-    discriminatorValue: DiscriminatorValue;
-    options: Map<DiscriminatorValue, Option>;
-    _option: Option;
-}
-declare type JSONDiscriminatedObject<Discriminator extends string, DiscriminatorValue extends Primitive> = JSONObject<{
-    [K in Discriminator]: JSONLiteral<DiscriminatorValue>;
-} & JSONObjectShape, any>;
-declare const discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends Primitive, Types extends [JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
-
-declare type JSONAny = JSONTypeAny & {
-    dataType: 'any';
-};
-declare type JSONBigInt = JSONType<bigint, 'bigint'> & {
-    data: BaseNumberData;
-} & typeof bigIntMethods;
-declare const bigIntMethods: {
-    lt<T extends {
-        data: {
-            lt?: number | undefined;
-        };
-    }, Value extends number>(this: T, value: Value): Omit<T, "data"> & {
-        data: Omit<T["data"], "lt"> & {
-            lt: Value;
-        };
-    };
-    lte<T_1 extends {
-        data: {
-            lte?: number | undefined;
-        };
-    }, Value_1 extends number>(this: T_1, value: Value_1): Omit<T_1, "data"> & {
-        data: Omit<T_1["data"], "lte"> & {
-            lte: Value_1;
-        };
-    };
-    max<T_2 extends {
-        data: {
-            lte?: number | undefined;
-        };
-    }, Value_2 extends number>(this: T_2, value: Value_2): Omit<T_2, "data"> & {
-        data: Omit<T_2["data"], "lte"> & {
-            lte: Value_2;
-        };
-    };
-    gt<T_3 extends {
-        data: {
-            gt?: number | undefined;
-        };
-    }, Value_3 extends number>(this: T_3, value: Value_3): Omit<T_3, "data"> & {
-        data: Omit<T_3["data"], "gt"> & {
-            gt: Value_3;
+    }, Value_3 extends number>(this: T_3, value: Value_3): Omit<T_3, "data"> & {
+        data: Omit<T_3["data"], "gt"> & {
+            gt: Value_3;
         };
     };
     gte<T_4 extends {
@@ -3794,6 +3601,9 @@ declare type JSONNumber = JSONType<number, 'number'> & {
 } & typeof numberMethods;
 declare const numberMethods: {
     dataType: "number";
+    toCode(this: JSONType<number, 'number'> & {
+        data: BaseNumberData;
+    }, t: string): Code;
     lt<T extends {
         data: {
             lt?: number | undefined;
@@ -3920,6 +3730,9 @@ declare type JSONString = JSONType<string, 'string'> & {
 } & typeof stringMethods;
 declare const stringMethods: {
     dataType: "string";
+    toCode(this: JSONType<string, 'string'> & {
+        data: BaseStringData;
+    }, t: string): Code;
     email<T extends {
         data: {
             email?: boolean | undefined;
@@ -4019,15 +3832,7 @@ declare const stringMethods: {
             length: Value_5;
         };
     };
-    nonempty: <T_11 extends {
-        data: {
-            min?: number | undefined;
-        };
-    }>(this: T_11) => Omit<T_11, "data"> & {
-        data: Omit<T_11["data"], "min"> & {
-            min: number;
-        };
-    };
+    nonEmpty: <T_11 extends NonEmptyBase>(this: T_11) => NonEmptyResult<T_11>;
 };
 declare type JSONUndefined = JSONType<undefined, 'undefined'>;
 declare type JSONUnknown = JSONType<unknown, 'unknown'>;
@@ -4047,10 +3852,30 @@ declare const scalarTypes: {
     void: () => JSONVoid;
 };
 
-interface JSONUnion<T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]> extends JSONType<T[number]['type'], 'union'> {
-    types: T;
+interface JSONRecord<Key extends JSONRecordKeyType, Value extends JSONTypeAny> extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
+    keyType: Key;
+    valueType: Value;
+    deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
 }
-declare const union: <T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T) => JSONUnion<T>;
+declare type JSONRecordKeyType = JSONType<string | number, 'string' | 'number'>;
+declare type Args<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = Args2<Key, Value> | Args1<Key>;
+declare type Args2<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = [
+    key: Key,
+    value: Value
+];
+declare type Args1<Value extends JSONTypeAny> = [value: Value];
+declare function record<KeyType extends JSONString | JSONNumber, ValueType extends JSONTypeAny>(...args: Args<KeyType, ValueType>): JSONRecord<KeyType, ValueType>;
+
+interface JSONSet<Value extends JSONTypeAny> extends JSONType<Set<Value['type']>, 'set'>, SetMethods {
+    data: JSONTypeData & {
+        min?: number;
+        max?: number;
+        size?: number;
+    };
+    valueType: Value;
+    deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
+}
+declare const set: <Value extends JSONTypeAny>(valueType: Value) => JSONSet<Value>;
 
 interface JSONTuple<T extends JSONTupleItems | [] = JSONTupleItems, Rest extends JSONTypeAny | null = null> extends JSONType<OutputTypeOfTupleWithRest<T, Rest>, 'tuple'> {
     items: T;
@@ -4068,35 +3893,10 @@ declare type OutputTypeOfTuple<T extends JSONTupleItems | []> = AssertArray<{
 declare type OutputTypeOfTupleWithRest<T extends JSONTupleItems | [], Rest extends JSONTypeAny | null = null> = Rest extends JSONTypeAny ? [...OutputTypeOfTuple<T>, ...Rest['type'][]] : OutputTypeOfTuple<T>;
 declare const tuple: <T extends [] | JSONTupleItems, Rest extends JSONTypeAny | null = null>(items: T, rest?: Rest) => JSONTuple<T, Rest>;
 
-interface JSONSet<Value extends JSONTypeAny> extends JSONType<Set<Value['type']>, 'set'>, SetMethods {
-    data: JSONTypeData & {
-        min?: number;
-        max?: number;
-        size?: number;
-    };
-    valueType: Value;
-    deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
-    nonEmpty(this: JSONSet<Value>): JSONSet<Value> & {
-        data: {
-            min: 1;
-        };
-    };
-}
-declare const set: <Value extends JSONTypeAny>(valueType: Value) => JSONSet<Value>;
-
-interface JSONRecord<Key extends JSONRecordKeyType, Value extends JSONTypeAny> extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
-    keyType: Key;
-    valueType: Value;
-    deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
+interface JSONUnion<T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]> extends JSONType<T[number]['type'], 'union'> {
+    types: T;
 }
-declare type JSONRecordKeyType = JSONType<string | number, 'string' | 'number'>;
-declare type Args<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = Args2<Key, Value> | Args1<Key>;
-declare type Args2<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = [
-    key: Key,
-    value: Value
-];
-declare type Args1<Value extends JSONTypeAny> = [value: Value];
-declare function record<KeyType extends JSONString | JSONNumber, ValueType extends JSONTypeAny>(...args: Args<KeyType, ValueType>): JSONRecord<KeyType, ValueType>;
+declare const union: <T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(types: T) => JSONUnion<T>;
 
 declare type JSONTypes = typeof jsonTypes;
 declare const jsonTypes: {
@@ -4163,6 +3963,7 @@ declare class JSONColumn<Type extends JSONTypeAny = JSONTypeAny> extends ColumnT
         schema: Type;
     };
     constructor(schemaOrFn: Type | ((j: JSONTypes) => Type));
+    toCode(t: string): Code;
 }
 declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
     dataType: "json";
@@ -4198,6 +3999,250 @@ declare class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
             type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | string[];
         };
     };
+    toCode(t: string): Code;
+}
+
+declare type ColumnsShape = Record<string, ColumnType>;
+declare type ColumnShapeOutput<Shape extends ColumnsShape> = {
+    [K in keyof Shape]: ColumnOutput<Shape[K]>;
+};
+declare type OptionalColumnsForInput<Shape extends ColumnsShape> = {
+    [K in keyof Shape]: SomeIsTrue<[
+        Shape[K]['isNullable'],
+        Shape[K]['hasDefault']
+    ]> extends true ? K : never;
+}[keyof Shape];
+declare type ColumnShapeInput<Shape extends ColumnsShape> = SetOptional<{
+    [K in keyof Shape]: ColumnInput<Shape[K]>;
+}, OptionalColumnsForInput<Shape>>;
+declare abstract class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}, typeof Operators.any> {
+    shape: Shape;
+    dataType: "object";
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    constructor(shape: Shape);
+}
+declare abstract class ArrayOfColumnsObjects<Shape extends ColumnsShape> extends ColumnType<{
+    [K in keyof Shape]: Shape[K]['type'];
+}[], typeof Operators.any> {
+    shape: Shape;
+    dataType: "array";
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    constructor(shape: Shape);
+}
+declare abstract class PluckResultColumnType<C extends ColumnType> extends ColumnType<C['type'][], typeof Operators.any> {
+}
+declare type SinglePrimaryKey<Shape extends ColumnsShape> = StringKey<{
+    [K in keyof Shape]: Shape[K]['isPrimaryKey'] extends true ? [
+        {
+            [S in keyof Shape]: Shape[S]['isPrimaryKey'] extends true ? S extends K ? never : S : never;
+        }[keyof Shape]
+    ] extends [never] ? K : never : never;
+}[keyof Shape]>;
+
+declare type ColumnOutput<T extends ColumnType> = T['type'];
+declare type ColumnInput<T extends ColumnType> = T['inputType'];
+declare type NullableColumn<T extends ColumnType> = Omit<T, 'type' | 'inputType' | 'operators'> & {
+    type: T['type'] | null;
+    inputType: T['inputType'] | null;
+    isNullable: true;
+    operators: Omit<T['operators'], 'equals' | 'not'> & {
+        equals: Operator<T['type'] | null>;
+        not: Operator<T['type'] | null>;
+    };
+};
+declare type AnyColumnType = ColumnType<any, Record<string, Operator<any>>>;
+declare type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType | {};
+declare type ColumnTypesBase = Record<string, AnyColumnTypeCreator>;
+declare type ValidationContext = any;
+declare type ColumnData = {
+    default?: unknown;
+    validationDefault?: unknown;
+    index?: Omit<SingleColumnIndexOptions, 'column'>;
+    comment?: string;
+    collate?: string;
+    compression?: string;
+    foreignKey?: ForeignKey<string, string[]>;
+    modifyQuery?: (q: Query) => void;
+    as?: ColumnType;
+};
+declare type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
+declare type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+declare type ForeignKey<Table extends string, Columns extends string[]> = ({
+    fn(): new () => {
+        table: Table;
+    };
+} | {
+    table: Table;
+}) & {
+    columns: Columns;
+} & ForeignKeyOptions;
+declare type DropMode = 'CASCADE' | 'RESTRICT';
+declare type ForeignKeyOptions = {
+    name?: string;
+    match?: ForeignKeyMatch;
+    onUpdate?: ForeignKeyAction;
+    onDelete?: ForeignKeyAction;
+    dropMode?: DropMode;
+};
+declare type IndexColumnOptions = {
+    column: string;
+    expression?: number | string;
+    collate?: string;
+    operator?: string;
+    order?: string;
+};
+declare type IndexOptions = {
+    name?: string;
+    unique?: boolean;
+    using?: string;
+    include?: MaybeArray<string>;
+    with?: string;
+    tablespace?: string;
+    where?: string;
+    dropMode?: 'CASCADE' | 'RESTRICT';
+};
+declare type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
+declare type ForeignKeyTable = new () => {
+    table: string;
+};
+declare type ForeignKeyTableWithColumns = new () => {
+    table: string;
+    columns: {
+        shape: ColumnsShape;
+    };
+};
+declare type ColumnNameOfTable<Table extends ForeignKeyTableWithColumns> = StringKey<keyof InstanceType<Table>['columns']['shape']>;
+declare type Code = string | Code[];
+declare const columnChainToCode: (chain: ColumnChain, t: string, code: Code, append: Code) => Code;
+declare const columnCode: (type: ColumnType, t: string, code: Code) => Code;
+declare type ColumnChain = (['transform', (input: unknown, ctx: ValidationContext) => unknown] | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny] | ['refine', (input: unknown) => unknown] | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown])[];
+declare abstract class ColumnType<Type = unknown, Ops extends Operators = Operators, InputType = Type> {
+    abstract dataType: string;
+    abstract operators: Ops;
+    abstract toCode(t: string): Code;
+    type: Type;
+    inputType: InputType;
+    data: ColumnData;
+    isPrimaryKey: boolean;
+    isHidden: boolean;
+    isNullable: boolean;
+    hasDefault: boolean;
+    encodeFn?: (input: any) => unknown;
+    parseFn?: (input: unknown) => unknown;
+    parseItem?: (input: string) => unknown;
+    chain: ColumnChain;
+    primaryKey<T extends ColumnType>(this: T): T & {
+        isPrimaryKey: true;
+    };
+    foreignKey<T extends ColumnType, Table extends ForeignKeyTableWithColumns, Column extends ColumnNameOfTable<Table>>(this: T, fn: () => Table, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
+        foreignKeyData: ForeignKey<InstanceType<Table>['table'], [Column]>;
+    };
+    foreignKey<T extends ColumnType, Table extends string, Column extends string>(this: T, table: Table, column: Column, options?: ForeignKeyOptions): Omit<T, 'foreignKeyData'> & {
+        foreignKeyData: ForeignKey<Table, [Column]>;
+    };
+    hidden<T extends ColumnType>(this: T): T & {
+        isHidden: true;
+    };
+    nullable<T extends ColumnType>(this: T): NullableColumn<T>;
+    encode<T extends ColumnType, Input>(this: T, fn: (input: Input) => unknown): Omit<T, 'inputType'> & {
+        inputType: Input;
+    };
+    parse<T extends ColumnType, Output>(this: T, fn: (input: T['type']) => Output): Omit<T, 'type'> & {
+        type: Output;
+    };
+    as<T extends ColumnType, C extends ColumnType<T['type'], Operators, T['inputType']>>(this: T, column: C): C;
+    toSQL(): string;
+    default<T extends ColumnType>(this: T, value: T['type'] | RawExpression): T & {
+        hasDefault: true;
+    };
+    index<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column'>): T;
+    unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
+    comment<T extends ColumnType>(this: T, comment: string): T;
+    validationDefault<T extends ColumnType>(this: T, value: T['type']): T;
+    compression<T extends ColumnType>(this: T, compression: string): T;
+    collate<T extends ColumnType>(this: T, collate: string): T;
+    modifyQuery<T extends ColumnType>(this: T, cb: (q: Query) => void): T;
+    transform<T extends ColumnType, Transformed>(this: T, fn: (input: T['type'], ctx: ValidationContext) => Transformed): Omit<T, 'type'> & {
+        type: Transformed;
+    };
+    to<T extends ColumnType, ToType extends ColumnType>(this: T, fn: (input: T['type']) => ToType['type'] | undefined, type: ToType): ToType;
+    refine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type']) => unknown): T & {
+        type: RefinedOutput;
+    };
+    superRefine<T extends ColumnType, RefinedOutput extends T['type']>(this: T, check: (arg: T['type'], ctx: ValidationContext) => unknown): T & {
+        type: RefinedOutput;
+    };
+}
+
+declare class BooleanColumn extends ColumnType<boolean, typeof Operators.boolean> {
+    dataType: "boolean";
+    operators: {
+        equals: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        not: ((key: string, value: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: boolean | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        in: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+        notIn: ((key: string, value: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[], values: unknown[]) => string) & {
+            type: Query | RawExpression<ColumnType<unknown, Operators, unknown>> | boolean[];
+        };
+    };
+    toCode(t: string): Code;
+    parseItem: (input: string) => boolean;
+}
+
+declare class EnumColumn<U extends string = string, T extends [U, ...U[]] = [U]> extends ColumnType<T[number], typeof Operators.any> {
+    enumName: string;
+    options: T;
+    operators: {
+        equals: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        not: ((key: string, value: any, values: unknown[]) => string) & {
+            type: any;
+        };
+        in: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+        notIn: ((key: string, value: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>, values: unknown[]) => string) & {
+            type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
+        };
+    };
+    dataType: string;
+    constructor(enumName: string, options: T);
+    toCode(t: string): Code;
+    toSql(): string;
 }
 
 declare type ArrayData<Item extends ColumnType> = ColumnData & {
@@ -4205,6 +4250,7 @@ declare type ArrayData<Item extends ColumnType> = ColumnData & {
     min?: number;
     max?: number;
     length?: number;
+    isNonEmpty?: true;
 };
 declare type ArrayMethods = typeof arrayMethods;
 interface ArrayColumn<Item extends ColumnType> extends ColumnType<Item['type'][], typeof Operators.array>, ArrayMethods {
@@ -4228,7 +4274,10 @@ declare class ArrayColumn<Item extends ColumnType> extends ColumnType<Item['type
     data: ArrayData<Item>;
     constructor(item: Item);
     toSQL(): string;
-    parseFn: (input: unknown) => unknown[];
+    toCode(this: ArrayColumn<Item>, t: string): Code;
+    parseFn: ((input: unknown) => unknown[]) & {
+        hideFromCode: boolean;
+    };
 }
 
 declare function timestamps<T extends ColumnType>(this: {
@@ -4244,23 +4293,28 @@ declare function timestamps<T extends ColumnType>(this: {
 
 declare type ColumnTypes = typeof columnTypes;
 declare type TableData = {
-    primaryKey?: {
+    primaryKey?: TableData.PrimaryKey;
+    indexes: TableData.Index[];
+    foreignKeys: TableData.ForeignKey[];
+};
+declare namespace TableData {
+    type PrimaryKey = {
         columns: string[];
         options?: {
             name?: string;
         };
     };
-    indexes: {
+    type Index = {
         columns: IndexColumnOptions[];
         options: IndexOptions;
-    }[];
-    foreignKeys: {
+    };
+    type ForeignKey = {
         columns: string[];
-        fnOrTable: (() => ForeignKeyModel) | string;
+        fnOrTable: (() => ForeignKeyTable) | string;
         foreignColumns: string[];
         options: ForeignKeyOptions;
-    }[];
-};
+    };
+}
 declare const newTableData: () => TableData;
 declare const getTableData: () => TableData;
 declare const resetTableData: (data?: TableData) => void;
@@ -4322,7 +4376,7 @@ declare const columnTypes: {
     macaddr: () => MacAddrColumn;
     macaddr8: () => MacAddr8Column;
     bit: <Length extends number>(length: Length) => BitColumn<Length>;
-    bitVarying: <Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined) => BitVaryingColumn<Length_1 | undefined>;
+    bitVarying: <Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined) => BitVaryingColumn<Length_1>;
     tsvector: () => TsVectorColumn;
     tsquery: () => TsQueryColumn;
     uuid: () => UUIDColumn;
@@ -4338,7 +4392,7 @@ declare const columnTypes: {
     unique(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): {};
     foreignKey: typeof foreignKey;
 };
-declare function foreignKey<Model extends ForeignKeyModelWithColumns, Columns extends [ColumnNameOfModel<Model>, ...ColumnNameOfModel<Model>[]]>(columns: string[], fn: () => Model, foreignColumns: Columns, options?: ForeignKeyOptions): EmptyObject;
+declare function foreignKey<Table extends ForeignKeyTableWithColumns, Columns extends [ColumnNameOfTable<Table>, ...ColumnNameOfTable<Table>[]]>(columns: string[], fn: () => Table, foreignColumns: Columns, options?: ForeignKeyOptions): EmptyObject;
 declare function foreignKey<Table extends string, Columns extends [string, ...string[]]>(columns: string[], table: Table, foreignColumns: Columns, options?: ForeignKeyOptions): EmptyObject;
 
 declare const cloneInstance: <T>(instance: T) => T;
@@ -4371,6 +4425,7 @@ declare abstract class VirtualColumn extends ColumnType<unknown, typeof Operator
             type: any[] | Query | RawExpression<ColumnType<unknown, Operators, unknown>>;
         };
     };
+    toCode(): never;
     create?(q: Query, ctx: CreateCtx, item: Record<string, unknown>, rowIndex: number): void;
     update?(q: Query, ctx: UpdateCtx, set: Record<string, unknown>): void;
 }
@@ -4388,4 +4443,4 @@ declare const setQueryObjectValue: <T extends {
     query: QueryData;
 }>(q: T, object: string, key: string, value: unknown) => T;
 
-export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayCardinality, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AssertArray, BaseNumberData, BaseRelation, BaseStringData, BeforeCallback, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, CoalesceString, ColumnData, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnNameOfModel, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnTypesBase, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, DateBaseColumn, DateColumn, DateColumnData, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalColumn, DecimalColumnData, DeepPartial, DefaultSelectColumns, Delete, DeleteMethodsNames, DeleteQueryData, DoublePrecisionColumn, DropMode, EMPTY_OBJECT, EmptyObject, EnumColumn, EnumLike, Except, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, For, ForeignKey, ForeignKeyModel, ForeignKeyModelWithColumns, ForeignKeyOptions, From, GetArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsEqual, JSONAny, JSONArray, JSONBigInt, JSONBoolean, JSONColumn, JSONDate, JSONDiscriminatedObject, JSONDiscriminatedUnion, JSONEnum, JSONInstanceOf, JSONIntersection, JSONLazy, JSONLiteral, JSONMap, JSONNaN, JSONNativeEnum, JSONNever, JSONNotNullable, JSONNotNullish, JSONNull, JSONNullable, JSONNullish, JSONNumber, JSONObject, JSONObjectShape, JSONOptional, JSONRecord, JSONRecordKeyType, JSONRequired, JSONSet, JSONString, JSONTextColumn, JSONTuple, JSONTupleItems, JSONType, JSONTypeAny, JSONTypeData, JSONTypes, JSONUndefined, JSONUnion, JSONUnknown, JSONVoid, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, Merge, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrderArg, OrderItem, OutputTypeOfTuple, OutputTypeOfTupleWithRest, OwnTypeProps, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, Primitive, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryError, QueryErrorName, QueryGet, QueryInput, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QueryReturnsAll, QuerySelectAll, QueryThen, QueryUpsert, QueryWithTable, RawExpression, RawMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SingleColumnIndexOptions, SinglePrimaryKey, SmallIntColumn, SmallSerialColumn, SomeIsTrue, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownKeysParam, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, ValidationContext, VarCharColumn, VirtualColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addQuestionMarks, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, applyMixins, array, arrayToEnum, baseObjectOutputType, checkIfASimpleQuery, cloneQueryArrays, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, flatten, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isQueryReturnsAll, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, raw, record, relationQueryKey, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, toSqlCacheKey, tuple, union };
+export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, AnyColumnType, AnyColumnTypeCreator, ArrayCardinality, ArrayColumn, ArrayData, ArrayOfColumnsObjects, AssertArray, BaseNumberData, BaseRelation, BaseStringData, BeforeCallback, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, CoalesceString, Code, ColumnChain, ColumnData, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnInput, ColumnNameOfTable, ColumnOperators, ColumnOutput, ColumnParser, ColumnShapeInput, ColumnShapeOutput, ColumnType, ColumnTypes, ColumnTypesBase, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, DateBaseColumn, DateColumn, DateColumnData, DateTimeBaseClass, DateTimeColumnData, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbTableOptions, DecimalBaseColumn, DecimalColumn, DecimalColumnData, DeepPartial, DefaultSelectColumns, Delete, DeleteMethodsNames, DeleteQueryData, DoublePrecisionColumn, DropMode, EMPTY_OBJECT, EmptyObject, EnumColumn, EnumLike, Except, Expression, ExpressionOfType, ExpressionOutput, FilterTuple, For, ForeignKey, ForeignKeyOptions, ForeignKeyTable, ForeignKeyTableWithColumns, From, GetArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsEqual, JSONAny, JSONArray, JSONBigInt, JSONBoolean, JSONColumn, JSONDate, JSONDiscriminatedObject, JSONDiscriminatedUnion, JSONEnum, JSONInstanceOf, JSONIntersection, JSONLazy, JSONLiteral, JSONMap, JSONNaN, JSONNativeEnum, JSONNever, JSONNotNullable, JSONNotNullish, JSONNull, JSONNullable, JSONNullish, JSONNumber, JSONObject, JSONObjectShape, JSONOptional, JSONRecord, JSONRecordKeyType, JSONRequired, JSONSet, JSONString, JSONTextColumn, JSONTuple, JSONTupleItems, JSONType, JSONTypeAny, JSONTypeData, JSONTypes, JSONUndefined, JSONUnion, JSONUnknown, JSONVoid, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MaybeArray, Merge, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NullableColumn, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operator, Operators, OrderArg, OrderItem, OutputTypeOfTuple, OutputTypeOfTupleWithRest, OwnTypeProps, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, Primitive, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryError, QueryErrorName, QueryGet, QueryInput, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryResultRow, QueryReturnType, QueryReturnsAll, QuerySelectAll, QueryThen, QueryUpsert, QueryWithTable, RawExpression, RawMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SetOptional, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SimpleSpread, SingleColumnIndexOptions, SinglePrimaryKey, SmallIntColumn, SmallSerialColumn, SomeIsTrue, SortDir, Spread, Sql, StringColumn, StringExpression, StringKey, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, ThenResult, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UnknownKeysParam, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, ValidationContext, VarCharColumn, VirtualColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addQuestionMarks, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, applyMixins, array, arrayToEnum, baseObjectOutputType, checkIfASimpleQuery, cloneQueryArrays, columnChainToCode, columnCode, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, flatten, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, identity, instanceOf, intersection, isQueryReturnsAll, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, raw, record, relationQueryKey, required, resetTableData, scalarTypes, set, setQueryObjectValue, singleQuote, toArray, toCode, toSql, toSqlCacheKey, tuple, union };