sonamu 0.2.55 → 0.2.56

package/dist/index.d.mts

@@ -1,14 +1,775 @@
 import { z } from 'zod';
-import { A as ApiParamType, e as ApiParam, E as EntityPropNode, T as TextProp, f as EntityProp, R as RelationProp, g as EntityIndex, h as EntityJson, S as SubsetQuery, i as EntitySubsetRow, j as TemplateKey, k as TemplateOptions, P as PathAndCode, G as GenerateOptions, l as RenderingNode, m as SonamuDBConfig, c as DatabaseDriver, K as KnexClient, b as KyselyClient, D as DBPreset, a as Database, n as SonamuDBBaseConfig, o as KnexConfig, p as KyselyConfig, q as KnexGenerator, r as KnexBaseConfig, s as SonamuKnexDBConfig, C as CodeGenerator, M as MigrationColumn, t as MigrationIndex, u as GenMigrationCode, v as MigrationForeign, w as KyselyBaseConfig, x as SonamuKyselyDBConfig, y as DatabaseExtend, I as IntegerProp, z as BigIntegerProp, F as StringProp, H as FloatProp, J as DoubleProp, L as DecimalProp, N as BooleanProp, O as DateProp, Q as DateTimeProp, V as TimeProp, W as TimestampProp, X as JsonProp, Y as UuidProp, Z as EnumProp, _ as VirtualProp, $ as DistributiveOmit, a0 as OneToOneRelationProp, a1 as BelongsToOneRelationProp, a2 as HasManyRelationProp, a3 as ManyToManyRelationProp, a4 as MigrationSet, a5 as MigrationSetAndJoinTable, a6 as FixtureSearchOptions, a7 as FixtureRecord, a8 as FixtureImportResult } from './model-CAH_4oQh.mjs';
-export { aS as ArrayOr, B as BaseListParams, aj as CommonProp, ac as DatabaseClient, d as DriverSpec, af as EnumsLabel, ag as EnumsLabelKo, ad as Environment, am as FlattenSubsetRow, aO as KnexColumnType, aL as KnexError, aR as ListResult, aP as MigrationJoinTable, aQ as RelationNode, al as RelationOn, ak as RelationType, an as SMDInput, ah as SQLDateTimeString, ae as SonamuDBFullConfig, aK as SonamuQueryMode, a9 as UBRef, U as UpsertBuilder, ab as WhereClause, aT as asArray, aG as isBelongsToOneRelationProp, ap as isBigIntegerProp, aw as isBooleanProp, aJ as isCustomJoinClause, ax as isDateProp, ay as isDateTimeProp, av as isDecimalProp, au as isDoubleProp, as as isEnumProp, at as isFloatProp, aH as isHasManyRelationProp, ao as isIntegerProp, aB as isJsonProp, aM as isKnexError, aN as isKyselyError, aI as isManyToManyRelationProp, aF as isOneToOneRelationProp, aa as isRefField, aE as isRelationProp, ar as isStringProp, aq as isTextProp, az as isTimeProp, aA as isTimestampProp, aC as isUuidProp, aD as isVirtualProp, aU as objToMap, ai as zArrayable } from './model-CAH_4oQh.mjs';
+import { Knex } from 'knex';
 import { HTTPMethods, FastifyReply, FastifyInstance, FastifyRequest } from 'fastify';
 import { RouteGenericInterface } from 'fastify/types/route';
 import { Server, IncomingMessage, ServerResponse, IncomingHttpHeaders } from 'http';
 import ts from 'typescript';
-import knex, { Knex } from 'knex';
-import * as kysely from 'kysely';
-import { Kysely } from 'kysely';
-import 'mysql2';
+
+type EnumsLabel<T extends string, L extends "ko" | "en"> = {
+    [key in T]: {
+        [lang in L]: string;
+    };
+};
+type EnumsLabelKo<T extends string> = EnumsLabel<T, "ko">;
+declare const SQLDateTimeString: z.ZodString;
+type SQLDateTimeString = z.infer<typeof SQLDateTimeString>;
+declare function zArrayable<T extends z.ZodTypeAny>(shape: T): z.ZodUnion<[T, z.ZodArray<T, "many">]>;
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type CommonProp = {
+    name: string;
+    nullable?: boolean;
+    toFilter?: true;
+    desc?: string;
+    dbDefault?: string;
+};
+type IntegerProp = CommonProp & {
+    type: "integer";
+    unsigned?: true;
+};
+type BigIntegerProp = CommonProp & {
+    type: "bigInteger";
+    unsigned?: true;
+};
+type TextProp = CommonProp & {
+    type: "text";
+    textType: "text" | "mediumtext" | "longtext";
+};
+type StringProp = CommonProp & {
+    type: "string";
+    length: number;
+};
+type EnumProp = CommonProp & {
+    type: "enum";
+    length: number;
+    id: string;
+};
+type FloatProp = CommonProp & {
+    type: "float";
+    unsigned?: true;
+    precision: number;
+    scale: number;
+};
+type DoubleProp = CommonProp & {
+    type: "double";
+    unsigned?: true;
+    precision: number;
+    scale: number;
+};
+type DecimalProp = CommonProp & {
+    type: "decimal";
+    unsigned?: true;
+    precision: number;
+    scale: number;
+};
+type BooleanProp = CommonProp & {
+    type: "boolean";
+};
+type DateProp = CommonProp & {
+    type: "date";
+};
+type DateTimeProp = CommonProp & {
+    type: "dateTime";
+};
+type TimeProp = CommonProp & {
+    type: "time";
+};
+type TimestampProp = CommonProp & {
+    type: "timestamp";
+};
+type JsonProp = CommonProp & {
+    type: "json";
+    id: string;
+};
+type UuidProp = CommonProp & {
+    type: "uuid";
+};
+type VirtualProp = CommonProp & {
+    type: "virtual";
+    id: string;
+};
+type RelationType = "HasMany" | "BelongsToOne" | "ManyToMany" | "OneToOne";
+type RelationOn = "CASCADE" | "SET NULL" | "NO ACTION" | "SET DEFAULT" | "RESTRICT";
+type _RelationProp = {
+    type: "relation";
+    name: string;
+    with: string;
+    nullable?: boolean;
+    toFilter?: true;
+    desc?: string;
+};
+type OneToOneRelationProp = _RelationProp & {
+    relationType: "OneToOne";
+    customJoinClause?: string;
+} & ({
+    hasJoinColumn: true;
+    onUpdate: RelationOn;
+    onDelete: RelationOn;
+} | {
+    hasJoinColumn: false;
+});
+type BelongsToOneRelationProp = _RelationProp & {
+    relationType: "BelongsToOne";
+    customJoinClause?: string;
+    onUpdate: RelationOn;
+    onDelete: RelationOn;
+};
+type HasManyRelationProp = _RelationProp & {
+    relationType: "HasMany";
+    joinColumn: string;
+    fromColumn?: string;
+};
+type ManyToManyRelationProp = _RelationProp & {
+    relationType: "ManyToMany";
+    joinTable: `${string}__${string}`;
+    onUpdate: RelationOn;
+    onDelete: RelationOn;
+};
+type RelationProp = OneToOneRelationProp | BelongsToOneRelationProp | HasManyRelationProp | ManyToManyRelationProp;
+type EntityProp = IntegerProp | BigIntegerProp | TextProp | StringProp | FloatProp | DoubleProp | DecimalProp | BooleanProp | DateProp | DateTimeProp | TimeProp | TimestampProp | JsonProp | UuidProp | EnumProp | VirtualProp | RelationProp;
+type EntityIndex = {
+    type: "index" | "unique";
+    columns: string[];
+    name?: string;
+};
+type EntityJson = {
+    id: string;
+    parentId?: string;
+    table: string;
+    title?: string;
+    props: EntityProp[];
+    indexes: EntityIndex[];
+    subsets: {
+        [subset: string]: string[];
+    };
+    enums: {
+        [enumId: string]: {
+            [key: string]: string;
+        };
+    };
+};
+type EntitySubsetRow = {
+    field: string;
+    has: {
+        [key: string]: boolean;
+    };
+    children: EntitySubsetRow[];
+    prefixes: string[];
+    relationEntity?: string;
+    isOpen?: boolean;
+};
+type FlattenSubsetRow = Omit<EntitySubsetRow, "children">;
+type SMDInput<T extends string> = {
+    id: string;
+    parentId?: string;
+    table?: string;
+    title?: string;
+    props?: EntityProp[];
+    indexes?: EntityIndex[];
+    subsets?: {
+        [subset: string]: T[];
+    };
+};
+type EntityPropNode = {
+    nodeType: "plain";
+    prop: EntityProp;
+} | {
+    nodeType: "object" | "array";
+    prop?: EntityProp;
+    children: EntityPropNode[];
+};
+declare function isIntegerProp(p: any): p is IntegerProp;
+declare function isBigIntegerProp(p: any): p is BigIntegerProp;
+declare function isTextProp(p: any): p is TextProp;
+declare function isStringProp(p: any): p is StringProp;
+declare function isEnumProp(p: any): p is EnumProp;
+declare function isFloatProp(p: any): p is FloatProp;
+declare function isDoubleProp(p: any): p is DoubleProp;
+declare function isDecimalProp(p: any): p is DecimalProp;
+declare function isBooleanProp(p: any): p is BooleanProp;
+declare function isDateProp(p: any): p is DateProp;
+declare function isDateTimeProp(p: any): p is DateTimeProp;
+declare function isTimeProp(p: any): p is TimeProp;
+declare function isTimestampProp(p: any): p is TimestampProp;
+declare function isJsonProp(p: any): p is JsonProp;
+declare function isUuidProp(p: any): p is UuidProp;
+declare function isVirtualProp(p: any): p is VirtualProp;
+declare function isRelationProp(p: any): p is RelationProp;
+declare function isOneToOneRelationProp(p: any): p is OneToOneRelationProp;
+declare function isBelongsToOneRelationProp(p: any): p is BelongsToOneRelationProp;
+declare function isHasManyRelationProp(p: any): p is HasManyRelationProp;
+declare function isManyToManyRelationProp(p: any): p is ManyToManyRelationProp;
+type JoinClause = {
+    from: string;
+    to: string;
+} | {
+    custom: string;
+};
+declare function isCustomJoinClause(p: any): p is {
+    custom: string;
+};
+type SubsetLoader = {
+    as: string;
+    table: string;
+    manyJoin: {
+        fromTable: string;
+        fromCol: string;
+        idField: string;
+        toTable: string;
+        toCol: string;
+        through?: {
+            table: string;
+            fromCol: string;
+            toCol: string;
+        };
+    };
+    oneJoins: ({
+        as: string;
+        join: "inner" | "outer";
+        table: string;
+    } & JoinClause)[];
+    select: (string | Knex.Raw)[];
+    loaders?: SubsetLoader[];
+};
+type SubsetQuery = {
+    select: (string | Knex.Raw)[];
+    virtual: string[];
+    joins: ({
+        as: string;
+        join: "inner" | "outer";
+        table: string;
+    } & JoinClause)[];
+    loaders: SubsetLoader[];
+};
+declare const SonamuQueryMode: z.ZodEnum<["both", "list", "count"]>;
+type SonamuQueryMode = z.infer<typeof SonamuQueryMode>;
+type KnexError = {
+    code: string;
+    errno: number;
+    sql: string;
+    sqlMessage: string;
+    sqlState: string;
+};
+declare function isKnexError(e: any): e is KnexError;
+type KnexColumnType = "string" | "text" | "smalltext" | "mediumtext" | "longtext" | "integer" | "bigInteger" | "decimal" | "timestamp" | "boolean" | "foreign" | "uuid" | "json" | "float" | "set" | "date" | "time" | "dateTime";
+type MigrationColumn = {
+    name: string;
+    type: KnexColumnType;
+    nullable: boolean;
+    unsigned?: boolean;
+    length?: number;
+    defaultTo?: string;
+    precision?: number;
+    scale?: number;
+};
+type MigrationIndex = {
+    columns: string[];
+    type: "unique" | "index";
+};
+type MigrationForeign = {
+    columns: string[];
+    to: string;
+    onUpdate: RelationOn;
+    onDelete: RelationOn;
+};
+type MigrationJoinTable = {
+    table: string;
+    indexes: MigrationIndex[];
+    columns: MigrationColumn[];
+    foreigns: MigrationForeign[];
+};
+type MigrationSet = {
+    table: string;
+    columns: MigrationColumn[];
+    indexes: MigrationIndex[];
+    foreigns: MigrationForeign[];
+};
+type MigrationSetAndJoinTable = MigrationSet & {
+    joinTables: MigrationJoinTable[];
+};
+type GenMigrationCode = {
+    title: string;
+    table: string;
+    type: "normal" | "foreign";
+    formatted: string | null;
+};
+type ApiParam = {
+    name: string;
+    type: ApiParamType;
+    optional: boolean;
+    defaultDef?: string;
+};
+declare namespace ApiParamType {
+    type Object = {
+        t: "object";
+        props: ApiParam[];
+    };
+    type Union = {
+        t: "union";
+        types: ApiParamType[];
+    };
+    type Intersection = {
+        t: "intersection";
+        types: ApiParamType[];
+    };
+    type StringLiteral = {
+        t: "string-literal";
+        value: string;
+    };
+    type NumericLiteral = {
+        t: "numeric-literal";
+        value: number;
+    };
+    type Array = {
+        t: "array";
+        elementsType: ApiParamType;
+    };
+    type Ref = {
+        t: "ref";
+        id: string;
+        args?: ApiParamType[];
+    };
+    type IndexedAccess = {
+        t: "indexed-access";
+        object: ApiParamType;
+        index: ApiParamType;
+    };
+    type TupleType = {
+        t: "tuple-type";
+        elements: ApiParamType[];
+    };
+    type Pick = Ref & {
+        t: "ref";
+        id: "Pick";
+    };
+    type Omit = Ref & {
+        t: "ref";
+        id: "Omit";
+    };
+    type Partial = Ref & {
+        t: "ref";
+        id: "Partial";
+    };
+    type Promise = Ref & {
+        t: "ref";
+        id: "Promise";
+    };
+    type Context = Ref & {
+        t: "ref";
+        id: "Context";
+    };
+    type TypeParam = {
+        t: "type-param";
+        id: string;
+        constraint?: ApiParamType;
+    };
+    function isObject(v: any): v is ApiParamType.Object;
+    function isUnion(v: any): v is ApiParamType.Union;
+    function isIntersection(v: any): v is ApiParamType.Intersection;
+    function isStringLiteral(v: any): v is ApiParamType.StringLiteral;
+    function isNumericLiteral(v: any): v is ApiParamType.NumericLiteral;
+    function isArray(v: any): v is ApiParamType.Array;
+    function isRef(v: any): v is ApiParamType.Ref;
+    function isIndexedAccess(v: any): v is ApiParamType.IndexedAccess;
+    function isTupleType(v: any): v is ApiParamType.TupleType;
+    function isPick(v: any): v is ApiParamType.Pick;
+    function isOmit(v: any): v is ApiParamType.Omit;
+    function isPartial(v: any): v is ApiParamType.Partial;
+    function isPromise(v: any): v is ApiParamType.Promise;
+    function isContext(v: any): v is ApiParamType.Context;
+    function isRefKnex(v: any): v is ApiParamType.Ref;
+    function isTypeParam(v: any): v is ApiParamType.TypeParam;
+}
+type ApiParamType = "string" | "number" | "boolean" | "null" | "undefined" | "void" | "any" | "unknown" | "true" | "false" | ApiParamType.StringLiteral | ApiParamType.NumericLiteral | ApiParamType.Object | ApiParamType.Union | ApiParamType.Intersection | ApiParamType.Array | ApiParamType.Ref | ApiParamType.IndexedAccess | ApiParamType.TypeParam | ApiParamType.TupleType;
+declare const RenderingNode: z.ZodAny;
+type RenderingNode = {
+    name: string;
+    label: string;
+    renderType: "string-plain" | "string-image" | "string-datetime" | "string-date" | "number-plain" | "number-id" | "number-fk_id" | "boolean" | "enums" | "array" | "array-images" | "object" | "object-pick" | "record";
+    zodType: z.ZodTypeAny;
+    element?: RenderingNode;
+    children?: RenderingNode[];
+    config?: {
+        picked: string;
+    };
+    optional?: boolean;
+    nullable?: boolean;
+};
+declare const TemplateOptions: z.ZodObject<{
+    entity: z.ZodObject<{
+        entityId: z.ZodString;
+        parentId: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        table: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">>;
+        indexes: z.ZodOptional<z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">>;
+        subsets: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+        enums: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        title: string;
+        parentId?: string | undefined;
+        table?: string | undefined;
+        props?: {}[] | undefined;
+        indexes?: {}[] | undefined;
+        subsets?: {} | undefined;
+        enums?: {} | undefined;
+    }, {
+        entityId: string;
+        title: string;
+        parentId?: string | undefined;
+        table?: string | undefined;
+        props?: {}[] | undefined;
+        indexes?: {}[] | undefined;
+        subsets?: {} | undefined;
+        enums?: {} | undefined;
+    }>;
+    init_types: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    generated: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    generated_sso: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    generated_http: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    model: z.ZodObject<{
+        entityId: z.ZodString;
+        defaultSearchField: z.ZodString;
+        defaultOrderBy: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        defaultSearchField: string;
+        defaultOrderBy: string;
+    }, {
+        entityId: string;
+        defaultSearchField: string;
+        defaultOrderBy: string;
+    }>;
+    model_test: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    bridge: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    service: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    view_list: z.ZodObject<{
+        entityId: z.ZodString;
+        extra: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        extra?: unknown;
+    }, {
+        entityId: string;
+        extra?: unknown;
+    }>;
+    view_list_columns: z.ZodObject<{
+        entityId: z.ZodString;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodString;
+            tc: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            label: string;
+            tc: string;
+        }, {
+            name: string;
+            label: string;
+            tc: string;
+        }>, "many">;
+        columnImports: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        columns: {
+            name: string;
+            label: string;
+            tc: string;
+        }[];
+        columnImports: string;
+    }, {
+        entityId: string;
+        columns: {
+            name: string;
+            label: string;
+            tc: string;
+        }[];
+        columnImports: string;
+    }>;
+    view_search_input: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    view_form: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    view_id_all_select: z.ZodObject<{
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+    }, {
+        entityId: string;
+    }>;
+    view_id_async_select: z.ZodObject<{
+        entityId: z.ZodString;
+        textField: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        textField: string;
+    }, {
+        entityId: string;
+        textField: string;
+    }>;
+    view_enums_select: z.ZodObject<{
+        entityId: z.ZodString;
+        enumId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        enumId: string;
+    }, {
+        entityId: string;
+        enumId: string;
+    }>;
+    view_enums_dropdown: z.ZodObject<{
+        entityId: z.ZodString;
+        enumId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        enumId: string;
+    }, {
+        entityId: string;
+        enumId: string;
+    }>;
+    view_enums_buttonset: z.ZodObject<{
+        entityId: z.ZodString;
+        enumId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityId: string;
+        enumId: string;
+    }, {
+        entityId: string;
+        enumId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    entity: {
+        entityId: string;
+        title: string;
+        parentId?: string | undefined;
+        table?: string | undefined;
+        props?: {}[] | undefined;
+        indexes?: {}[] | undefined;
+        subsets?: {} | undefined;
+        enums?: {} | undefined;
+    };
+    init_types: {
+        entityId: string;
+    };
+    generated: {};
+    generated_sso: {};
+    generated_http: {
+        entityId: string;
+    };
+    model: {
+        entityId: string;
+        defaultSearchField: string;
+        defaultOrderBy: string;
+    };
+    model_test: {
+        entityId: string;
+    };
+    bridge: {
+        entityId: string;
+    };
+    service: {
+        entityId: string;
+    };
+    view_list: {
+        entityId: string;
+        extra?: unknown;
+    };
+    view_list_columns: {
+        entityId: string;
+        columns: {
+            name: string;
+            label: string;
+            tc: string;
+        }[];
+        columnImports: string;
+    };
+    view_search_input: {
+        entityId: string;
+    };
+    view_form: {
+        entityId: string;
+    };
+    view_id_all_select: {
+        entityId: string;
+    };
+    view_id_async_select: {
+        entityId: string;
+        textField: string;
+    };
+    view_enums_select: {
+        entityId: string;
+        enumId: string;
+    };
+    view_enums_dropdown: {
+        entityId: string;
+        enumId: string;
+    };
+    view_enums_buttonset: {
+        entityId: string;
+        enumId: string;
+    };
+}, {
+    entity: {
+        entityId: string;
+        title: string;
+        parentId?: string | undefined;
+        table?: string | undefined;
+        props?: {}[] | undefined;
+        indexes?: {}[] | undefined;
+        subsets?: {} | undefined;
+        enums?: {} | undefined;
+    };
+    init_types: {
+        entityId: string;
+    };
+    generated: {};
+    generated_sso: {};
+    generated_http: {
+        entityId: string;
+    };
+    model: {
+        entityId: string;
+        defaultSearchField: string;
+        defaultOrderBy: string;
+    };
+    model_test: {
+        entityId: string;
+    };
+    bridge: {
+        entityId: string;
+    };
+    service: {
+        entityId: string;
+    };
+    view_list: {
+        entityId: string;
+        extra?: unknown;
+    };
+    view_list_columns: {
+        entityId: string;
+        columns: {
+            name: string;
+            label: string;
+            tc: string;
+        }[];
+        columnImports: string;
+    };
+    view_search_input: {
+        entityId: string;
+    };
+    view_form: {
+        entityId: string;
+    };
+    view_id_all_select: {
+        entityId: string;
+    };
+    view_id_async_select: {
+        entityId: string;
+        textField: string;
+    };
+    view_enums_select: {
+        entityId: string;
+        enumId: string;
+    };
+    view_enums_dropdown: {
+        entityId: string;
+        enumId: string;
+    };
+    view_enums_buttonset: {
+        entityId: string;
+        enumId: string;
+    };
+}>;
+type TemplateOptions = z.infer<typeof TemplateOptions>;
+declare const TemplateKey: z.ZodEnum<["entity", "init_types", "generated", "generated_sso", "generated_http", "model", "model_test", "bridge", "service", "view_list", "view_list_columns", "view_search_input", "view_form", "view_id_all_select", "view_id_async_select", "view_enums_select", "view_enums_dropdown", "view_enums_buttonset"]>;
+type TemplateKey = z.infer<typeof TemplateKey>;
+declare const GenerateOptions: z.ZodObject<{
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    overwrite?: boolean | undefined;
+}, {
+    overwrite?: boolean | undefined;
+}>;
+type GenerateOptions = z.infer<typeof GenerateOptions>;
+declare const PathAndCode: z.ZodObject<{
+    path: z.ZodString;
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    code: string;
+}, {
+    path: string;
+    code: string;
+}>;
+type PathAndCode = z.infer<typeof PathAndCode>;
+type FixtureSearchOptions = {
+    entityId: string;
+    field: string;
+    value: string;
+    searchType: "equals" | "like";
+};
+type FixtureRecord = {
+    fixtureId: string;
+    entityId: string;
+    id: number;
+    columns: {
+        [key: string]: {
+            prop: EntityProp;
+            value: any;
+        };
+    };
+    fetchedRecords: string[];
+    belongsRecords: string[];
+    target?: FixtureRecord;
+    unique?: FixtureRecord;
+    override?: boolean;
+};
+type FixtureImportResult = {
+    entityId: string;
+    data: {
+        [key: string]: any;
+    };
+};
 
 type ServiceClient = "axios" | "axios-multipart" | "swr" | "socketio" | "window-fetch";
 type ApiDecoratorOptions = {
@@ -101,7 +862,7 @@ declare class Entity {
     fieldExprsToPropNodes(fieldExprs: string[], entity?: Entity): EntityPropNode[];
     getFieldExprs(prefix?: string, maxDepth?: number, froms?: string[]): string[];
     getTableColumns(): string[];
-    registerModulePaths(): Promise<void>;
+    registerModulePaths(): void;
     registerTableSpecs(): void;
     toJson(): EntityJson;
     save(): Promise<void>;
@@ -135,7 +896,7 @@ declare class EntityManagerClass {
     isAutoloaded: boolean;
     autoload(doSilent?: boolean): Promise<unknown>;
     reload(doSilent?: boolean): Promise<unknown>;
-    register(json: EntityJson): Promise<void>;
+    register(json: EntityJson): void;
     get(entityId: string): Entity;
     exists(entityId: string): boolean;
     getAllIds(): string[];
@@ -190,7 +951,6 @@ declare class Syncer {
     models: {
         [modelName: string]: unknown;
     };
-    isSyncing: boolean;
     get checksumsPath(): string;
     constructor();
     sync(): Promise<void>;
@@ -263,8 +1023,27 @@ declare class Syncer {
     }>;
 }
 
+type DBPreset = "w" | "r";
+
+type SonamuDBConfig = {
+    development_master: Knex.Config;
+    development_slave: Knex.Config;
+    test: Knex.Config;
+    fixture_local: Knex.Config;
+    fixture_remote: Knex.Config;
+    production_master: Knex.Config;
+    production_slave: Knex.Config;
+};
+declare class DBClass {
+    private wdb?;
+    private rdb?;
+    readKnexfile(): Promise<SonamuDBConfig>;
+    getDB(which: DBPreset): Knex;
+    destroy(): Promise<void>;
+}
+declare const DB: DBClass;
+
 type SonamuConfig = {
-    projectName?: string;
     api: {
         dir: string;
     };
@@ -312,9 +1091,6 @@ declare class SonamuClass {
     private _dbConfig;
     set dbConfig(dbConfig: SonamuDBConfig);
     get dbConfig(): SonamuDBConfig;
-    private _dbClient;
-    set dbClient(_dbClient: DatabaseDriver);
-    get dbClient(): DatabaseDriver;
     private _syncer;
     set syncer(syncer: Syncer);
     get syncer(): Syncer;
@@ -324,8 +1100,7 @@ declare class SonamuClass {
     private _secrets;
     set secrets(secrets: SonamuSecrets);
     get secrets(): SonamuSecrets | null;
-    initForTesting(): Promise<void>;
-    init(doSilent?: boolean, enableSync?: boolean, apiRootPath?: string, forTesting?: boolean): Promise<void>;
+    init(doSilent?: boolean, enableSync?: boolean, apiRootPath?: string): Promise<void>;
     withFastify(server: FastifyInstance<Server, IncomingMessage, ServerResponse>, config: SonamuFastifyConfig, options?: {
         enableSync?: boolean;
         doSilent?: boolean;
@@ -334,208 +1109,88 @@ declare class SonamuClass {
 }
 declare const Sonamu: SonamuClass;
 
-declare abstract class DBClass {
-    _fullConfig?: SonamuDBConfig;
-    set fullConfig(config: SonamuDBConfig);
-    get fullConfig(): SonamuDBConfig;
-    abstract tdb: KnexClient | KyselyClient;
-    abstract fdb: KnexClient | KyselyClient;
-    abstract testInit(): Promise<void>;
-    abstract getDB(which: DBPreset): Knex | Kysely<Database>;
-    abstract destroy(): Promise<void>;
-    abstract raw(db: Knex | Kysely<Database>, query: string): any;
-    getBaseConfig(rootPath: string): Promise<SonamuDBBaseConfig>;
-    getCurrentConfig(which?: DBPreset): KnexConfig | KyselyConfig;
-    toClient(db: Knex | Kysely<Database>): KnexClient | KyselyClient;
+type ListResult<T> = {
+    rows: T[];
+    total?: number;
+};
+type ArrayOr<T> = T | T[];
+declare function asArray<T>(param: T | T[]): T[];
+declare function objToMap<T>(obj: {
+    [k: string]: T;
+}): Map<number, T> | Map<string, T>;
+interface BaseListParams {
+    id?: number | number[];
+    num?: number;
+    page?: number;
+    keyword?: string;
+    queryMode?: "list" | "count" | "both";
 }
 
-declare class DBKnexClass extends DBClass {
-    migrationTable: string;
-    generator: KnexGenerator;
-    baseConfig?: KnexBaseConfig;
-    _fullConfig?: SonamuKnexDBConfig;
-    set fullConfig(config: SonamuKnexDBConfig);
-    get fullConfig(): SonamuKnexDBConfig;
-    private wdb?;
-    private rdb?;
-    private _tdb;
-    set tdb(tdb: KnexClient);
-    get tdb(): KnexClient;
-    private _fdb;
-    set fdb(fdb: KnexClient);
-    get fdb(): KnexClient;
-    get connectionInfo(): {
-        development_master: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        development_slave: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        test: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        fixture_local: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        fixture_remote: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        production_master: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-        production_slave: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | ((() => string | Promise<string>) & string) | undefined;
-        };
-    };
-    constructor();
-    init(config: KnexBaseConfig): void;
-    testInit(): Promise<void>;
-    getDB(which: DBPreset): knex.Knex<any, any[]>;
-    getClient(mode: keyof SonamuKnexDBConfig): KnexClient;
-    destroy(): Promise<void>;
-    testDestroy(): Promise<void>;
-    raw(db: Knex, query: string): Knex.Raw<any>;
-    private generateDBConfig;
-    /**
-     * keys에 해당하는 설정들을 중복없이 가져옵니다. (host/port/database가 같은 설정은 중복으로 처리합니다.)
-     */
-    getUniqueConfigs(keys: (keyof SonamuKnexDBConfig)[]): {
-        connKey: keyof SonamuKnexDBConfig;
-        options: KnexConfig;
+type TableData = {
+    references: Set<string>;
+    rows: any[];
+    uniqueIndexes: {
+        name?: string;
+        columns: string[];
     }[];
+    uniquesMap: Map<string, string>;
+};
+type UBRef = {
+    uuid: string;
+    of: string;
+    use?: string;
+};
+declare function isRefField(field: any): field is UBRef;
+declare class UpsertBuilder {
+    tables: Map<string, TableData>;
+    constructor();
+    getTable(tableName: string): TableData;
+    hasTable(tableName: string): boolean;
+    register<T extends string>(tableName: string, row: {
+        [key in T]?: UBRef | string | number | boolean | bigint | null | object | unknown;
+    }): UBRef;
+    upsert(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]>;
+    insertOnly(wdb: Knex, tableName: string, chunkSize?: number): Promise<number[]>;
+    upsertOrInsert(wdb: Knex, tableName: string, mode: "upsert" | "insert", chunkSize?: number): Promise<number[]>;
+    updateBatch(wdb: Knex, tableName: string, options?: {
+        chunkSize?: number;
+        where?: string | string[];
+    }): Promise<void>;
 }
 
-declare class KyselyGenerator extends CodeGenerator {
-    generateCreateCode_ColumnAndIndexes(table: string, columns: MigrationColumn[], indexes: MigrationIndex[]): Promise<GenMigrationCode>;
-    generateCreateCode_Foreign(table: string, foreigns: MigrationForeign[]): Promise<GenMigrationCode[]>;
-    generateAlterCode_ColumnAndIndexes(table: string, entityColumns: MigrationColumn[], entityIndexes: MigrationIndex[], dbColumns: MigrationColumn[], dbIndexes: MigrationIndex[]): Promise<GenMigrationCode[]>;
-    generateAlterCode_Foreigns(table: string, entityForeigns: MigrationForeign[], dbForeigns: MigrationForeign[]): Promise<GenMigrationCode[]>;
-    generateModelTemplate(entityId: string, def: {
-        orderBy: string;
-        search: string;
-    }): string;
-    private genColumnDefinitions;
-    private genIndexDefinitions;
-    private genForeignDefinitions;
-    private getAlterColumnLinesTo;
-    private getAlterIndexLinesTo;
-    private createIndexName;
-}
-
-declare class DBKyselyClass extends DBClass {
-    migrationTable: string;
-    generator: KyselyGenerator;
-    baseConfig?: KyselyBaseConfig;
-    _fullConfig?: SonamuKyselyDBConfig;
-    set fullConfig(config: SonamuKyselyDBConfig);
-    get fullConfig(): SonamuKyselyDBConfig;
-    private wdb?;
-    private rdb?;
-    private _tdb;
-    set tdb(tdb: KyselyClient);
-    get tdb(): KyselyClient;
-    private _fdb;
-    set fdb(fdb: KyselyClient);
-    get fdb(): KyselyClient;
-    get connectionInfo(): {
-        development_master: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        development_slave: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        test: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        fixture_local: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        fixture_remote: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        production_master: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-        production_slave: {
-            host: string;
-            port: number;
-            database: string | undefined;
-            user: string | undefined;
-            password: string | undefined;
-        };
-    };
-    constructor();
-    init(config: KyselyBaseConfig): void;
-    testInit(): Promise<void>;
-    get config(): SonamuKyselyDBConfig;
-    getDB(which: DBPreset): Kysely<DatabaseExtend>;
-    getClient(mode: keyof SonamuKyselyDBConfig): KyselyClient;
+declare class BaseModelClass {
+    modelName: string;
+    getDB(which: DBPreset): Knex;
     destroy(): Promise<void>;
-    testDestroy(): Promise<void>;
-    raw(db: Kysely<Database>, query: string): Promise<kysely.QueryResult<unknown>>;
-    private generateDBConfig;
-    /**
-     * keys에 해당하는 설정들을 중복없이 가져옵니다. (host/port/database가 같은 설정은 중복으로 처리합니다.)
-     */
-    getUniqueConfigs(keys: (keyof SonamuKyselyDBConfig)[]): {
-        connKey: keyof SonamuKyselyDBConfig;
-        options: KyselyConfig;
-    }[];
+    myNow(timestamp?: number): string;
+    getInsertedIds(wdb: Knex, rows: any[], tableName: string, unqKeyFields: string[], chunkSize?: number): Promise<number[]>;
+    useLoaders(db: Knex, rows: any[], loaders: SubsetQuery["loaders"]): Promise<any[]>;
+    hydrate<T>(rows: T[]): T[];
+    runSubsetQuery<T extends BaseListParams, U extends string>({ params, baseTable, subset, subsetQuery, build, debug, db: _db, optimizeCountQuery, }: {
+        subset: U;
+        params: T;
+        subsetQuery: SubsetQuery;
+        build: (buildParams: {
+            qb: Knex.QueryBuilder;
+            db: Knex;
+            select: (string | Knex.Raw)[];
+            joins: SubsetQuery["joins"];
+            virtual: string[];
+        }) => Knex.QueryBuilder;
+        baseTable?: string;
+        debug?: boolean | "list" | "count";
+        db?: Knex;
+        optimizeCountQuery?: boolean;
+    }): Promise<{
+        rows: any[];
+        total?: number | undefined;
+        subsetQuery: SubsetQuery;
+        qb: Knex.QueryBuilder;
+    }>;
+    getJoinClause(db: Knex<any, unknown>, join: SubsetQuery["joins"][number]): Knex.Raw<any>;
+    getUpsertBuilder(): UpsertBuilder;
 }
-
-declare const DB: DBKnexClass | DBKyselyClass;
+declare const BaseModel: BaseModelClass;
 
 declare function setupErrorHandler(server: FastifyInstance): void;
 
@@ -670,10 +1325,10 @@ type MigrationStatus = {
 declare class Migrator {
     readonly mode: MigratorMode;
     targets: {
-        compare?: KnexClient | KyselyClient;
-        pending: KnexClient | KyselyClient;
-        shadow: KnexClient | KyselyClient;
-        apply: (KnexClient | KyselyClient)[];
+        compare?: Knex;
+        pending: Knex;
+        shadow: Knex;
+        apply: Knex[];
     };
     constructor(options: MigratorOptions);
     getMigrationCodes(): Promise<{
@@ -700,12 +1355,55 @@ declare class Migrator {
         applied: string[];
     }[]>;
     resetAll(): Promise<void>;
-    compareMigrations(compareDB: KnexClient | KyselyClient): Promise<GenMigrationCode[]>;
-    getMigrationSetFromDB(compareDB: KnexClient | KyselyClient, table: string): Promise<MigrationSet | null>;
+    compareMigrations(compareDB: Knex): Promise<GenMigrationCode[]>;
+    getMigrationSetFromDB(compareDB: Knex, table: string): Promise<MigrationSet | null>;
     resolveDBColType(colType: string, colField: string): Pick<MigrationColumn, "type" | "unsigned" | "length" | "precision" | "scale">;
-    readTable(compareDB: KnexClient | KyselyClient, tableName: string): Promise<[DBColumn[], DBIndex[], DBForeign[]]>;
-    getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTable;
-    showMigrationSet(which: "Entity" | "DB", migrationSet: MigrationSet): void;
+    readTable(compareDB: Knex, tableName: string): Promise<[DBColumn[], DBIndex[], DBForeign[]]>;
+    getMigrationSetFromMD(entity: Entity): MigrationSetAndJoinTable;
+    genColumnDefinitions(columns: MigrationColumn[]): string[];
+    genIndexDefinitions(indexes: MigrationIndex[]): string[];
+    genForeignDefinitions(table: string, foreigns: MigrationForeign[]): {
+        up: string[];
+        down: string[];
+    };
+    generateCreateCode_ColumnAndIndexes(table: string, columns: MigrationColumn[], indexes: MigrationIndex[]): Promise<GenMigrationCode>;
+    generateCreateCode_Foreign(table: string, foreigns: MigrationForeign[]): Promise<GenMigrationCode[]>;
+    showMigrationSet(which: string, migrationSet: MigrationSet): void;
+    generateAlterCode_ColumnAndIndexes(table: string, entityColumns: MigrationColumn[], entityIndexes: MigrationIndex[], dbColumns: MigrationColumn[], dbIndexes: MigrationIndex[]): Promise<GenMigrationCode[]>;
+    getAlterColumnsTo(entityColumns: MigrationColumn[], dbColumns: MigrationColumn[]): {
+        add: MigrationColumn[];
+        drop: MigrationColumn[];
+        alter: MigrationColumn[];
+    };
+    getAlterColumnLinesTo(columnsTo: ReturnType<Migrator["getAlterColumnsTo"]>, entityColumns: MigrationColumn[]): {
+        add: {
+            up: string[];
+            down: string[];
+        };
+        drop: {
+            up: string[];
+            down: string[];
+        };
+        alter: {
+            up: string[];
+            down: string[];
+        };
+    };
+    getAlterIndexesTo(entityIndexes: MigrationIndex[], dbIndexes: MigrationIndex[]): {
+        add: MigrationIndex[];
+        drop: MigrationIndex[];
+    };
+    getAlterIndexLinesTo(indexesTo: ReturnType<Migrator["getAlterIndexesTo"]>, columnsTo: ReturnType<Migrator["getAlterColumnsTo"]>): {
+        add: {
+            up: string[];
+            down: string[];
+        };
+        drop: {
+            up: string[];
+            down: string[];
+        };
+    };
+    generateAlterCode_Foreigns(table: string, entityForeigns: MigrationForeign[], dbForeigns: MigrationForeign[]): Promise<GenMigrationCode[]>;
     destroy(): Promise<void>;
 }
 type DBColumn = {
@@ -743,10 +1441,16 @@ type DBForeign = {
 };
 
 declare class FixtureManagerClass {
-    private relationGraph;
+    private _tdb;
+    set tdb(tdb: Knex);
+    get tdb(): Knex;
+    private _fdb;
+    set fdb(fdb: Knex);
+    get fdb(): Knex;
+    private dependencyGraph;
     init(): void;
     cleanAndSeed(usingTables?: string[]): Promise<void>;
-    getChecksum(db: KnexClient | KyselyClient, tableName: string): Promise<string>;
+    getChecksum(db: Knex, tableName: string): Promise<any>;
     sync(): Promise<void>;
     importFixture(entityId: string, ids: number[]): Promise<void>;
     getImportQueries(entityId: string, field: string, id: number): Promise<string[]>;
@@ -754,10 +1458,12 @@ declare class FixtureManagerClass {
     getFixtures(sourceDBName: keyof SonamuDBConfig, targetDBName: keyof SonamuDBConfig, searchOptions: FixtureSearchOptions): Promise<FixtureRecord[]>;
     createFixtureRecord(entity: Entity, row: any, options?: {
         singleRecord?: boolean;
-        _db?: KnexClient | KyselyClient;
-    }): Promise<FixtureRecord[]>;
+        _db?: Knex;
+    }, visitedEntities?: Set<string>): Promise<FixtureRecord[]>;
     insertFixtures(dbName: keyof SonamuDBConfig, _fixtures: FixtureRecord[]): Promise<FixtureImportResult[]>;
+    private getInsertionOrder;
     private prepareInsertData;
+    private buildDependencyGraph;
     private insertFixture;
     private handleManyToManyRelations;
     addFixtureLoader(code: string): Promise<void>;
@@ -780,8 +1486,7 @@ declare function importMultiple(filePaths: string[], doRefresh?: boolean): Promi
     imported: any;
 }[]>;
 declare function findAppRootPath(): Promise<string>;
-declare function findApiRootPath(): string;
+declare function findApiRootPath(): Promise<string>;
 declare function nonNullable<T>(value: T): value is NonNullable<T>;
-declare function hydrate<T>(rows: T[]): T[];
 
-export { AlreadyProcessedException, type ApiDecoratorOptions, ApiParam, ApiParamType, BadRequestException, BelongsToOneRelationProp, BigIntegerProp, BooleanProp, type Context, type ContextExtend, DB, DBPreset, Database, DatabaseDriver, DatabaseExtend, DateProp, DateTimeProp, DecimalProp, DistributiveOmit, DoubleProp, DuplicateRowException, Entity, EntityIndex, EntityJson, EntityManager, type EntityNamesRecord, EntityProp, EntityPropNode, EntitySubsetRow, EnumProp, type ExtendedApi, FixtureImportResult, FixtureManager, FixtureManagerClass, FixtureRecord, FixtureSearchOptions, FloatProp, GenMigrationCode, GenerateOptions, HasManyRelationProp, IntegerProp, InternalServerErrorException, JsonProp, KnexBaseConfig, KnexConfig, KyselyBaseConfig, KyselyConfig, ManyToManyRelationProp, MigrationColumn, MigrationForeign, MigrationIndex, MigrationSet, MigrationSetAndJoinTable, type MigrationStatus, Migrator, type MigratorOptions, NotFoundException, OneToOneRelationProp, PathAndCode, RelationProp, type RenderedTemplate, RenderingNode, type ServiceClient, ServiceUnavailableException, SoException, Sonamu, type SonamuConfig, SonamuDBBaseConfig, SonamuDBConfig, SonamuKnexDBConfig, SonamuKyselyDBConfig, type SonamuSecrets, StringProp, SubsetQuery, Syncer, TargetNotFoundException, TemplateKey, TemplateOptions, TextProp, TimeProp, TimestampProp, UnauthorizedException, UuidProp, VirtualProp, api, apiParamToTsCode, apiParamTypeToTsType, findApiRootPath, findAppRootPath, getTextTypeLength, getZodObjectFromApi, getZodObjectFromApiParams, getZodTypeFromApiParamType, globAsync, hydrate, i, importMultiple, isDaemonServer, isDevelopment, isInDocker, isLocal, isProduction, isRemote, isSoException, isStaging, isTest, nonNullable, p, propNodeToZodTypeDef, propToZodTypeDef, registeredApis, serializeZodType, setupErrorHandler, unwrapPromiseOnce, zodTypeToTsTypeDef, zodTypeToZodCode };
+export { AlreadyProcessedException, type ApiDecoratorOptions, type ApiParam, ApiParamType, type ArrayOr, BadRequestException, type BaseListParams, BaseModel, BaseModelClass, type BelongsToOneRelationProp, type BigIntegerProp, type BooleanProp, type CommonProp, type Context, type ContextExtend, DB, type DBPreset, type DateProp, type DateTimeProp, type DecimalProp, type DistributiveOmit, type DoubleProp, DuplicateRowException, Entity, type EntityIndex, type EntityJson, EntityManager, type EntityNamesRecord, type EntityProp, type EntityPropNode, type EntitySubsetRow, type EnumProp, type EnumsLabel, type EnumsLabelKo, type ExtendedApi, type FixtureImportResult, FixtureManager, FixtureManagerClass, type FixtureRecord, type FixtureSearchOptions, type FlattenSubsetRow, type FloatProp, type GenMigrationCode, GenerateOptions, type HasManyRelationProp, type IntegerProp, InternalServerErrorException, type JsonProp, type KnexColumnType, type KnexError, type ListResult, type ManyToManyRelationProp, type MigrationColumn, type MigrationForeign, type MigrationIndex, type MigrationJoinTable, type MigrationSet, type MigrationSetAndJoinTable, type MigrationStatus, Migrator, type MigratorOptions, NotFoundException, type OneToOneRelationProp, PathAndCode, type RelationOn, type RelationProp, type RelationType, type RenderedTemplate, RenderingNode, type SMDInput, SQLDateTimeString, type ServiceClient, ServiceUnavailableException, SoException, Sonamu, type SonamuConfig, type SonamuDBConfig, SonamuQueryMode, type SonamuSecrets, type StringProp, type SubsetQuery, Syncer, TargetNotFoundException, TemplateKey, TemplateOptions, type TextProp, type TimeProp, type TimestampProp, type UBRef, UnauthorizedException, UpsertBuilder, type UuidProp, type VirtualProp, api, apiParamToTsCode, apiParamTypeToTsType, asArray, findApiRootPath, findAppRootPath, getTextTypeLength, getZodObjectFromApi, getZodObjectFromApiParams, getZodTypeFromApiParamType, globAsync, i, importMultiple, isBelongsToOneRelationProp, isBigIntegerProp, isBooleanProp, isCustomJoinClause, isDaemonServer, isDateProp, isDateTimeProp, isDecimalProp, isDevelopment, isDoubleProp, isEnumProp, isFloatProp, isHasManyRelationProp, isInDocker, isIntegerProp, isJsonProp, isKnexError, isLocal, isManyToManyRelationProp, isOneToOneRelationProp, isProduction, isRefField, isRelationProp, isRemote, isSoException, isStaging, isStringProp, isTest, isTextProp, isTimeProp, isTimestampProp, isUuidProp, isVirtualProp, nonNullable, objToMap, p, propNodeToZodTypeDef, propToZodTypeDef, registeredApis, serializeZodType, setupErrorHandler, unwrapPromiseOnce, zArrayable, zodTypeToTsTypeDef, zodTypeToZodCode };