sonamu 0.2.49 → 0.2.50

package/dist/index.d.mts

@@ -0,0 +1,1492 @@
+import { z } from 'zod';
+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';
+
+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" | "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 = {
+    httpMethod?: HTTPMethods;
+    contentType?: "text/plain" | "text/html" | "text/xml" | "application/json" | "application/octet-stream";
+    clients?: ServiceClient[];
+    path?: string;
+    resourceName?: string;
+    guards?: string[];
+    description?: string;
+};
+declare const registeredApis: {
+    modelName: string;
+    methodName: string;
+    path: string;
+    options: ApiDecoratorOptions;
+}[];
+type ExtendedApi = {
+    modelName: string;
+    methodName: string;
+    path: string;
+    options: ApiDecoratorOptions;
+    typeParameters: ApiParamType.TypeParam[];
+    parameters: ApiParam[];
+    returnType: ApiParamType;
+};
+declare function api(options?: ApiDecoratorOptions): (target: Object, propertyKey: string) => void;
+
+declare function getZodObjectFromApi(api: ExtendedApi, references?: {
+    [id: string]: z.ZodObject<any>;
+}): z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare function getZodObjectFromApiParams(apiParams: ApiParam[], references?: {
+    [id: string]: z.ZodObject<any>;
+}): z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare function getZodTypeFromApiParamType(paramType: ApiParamType, references: {
+    [id: string]: z.ZodObject<any>;
+}): z.ZodType<unknown>;
+declare function propNodeToZodTypeDef(propNode: EntityPropNode, injectImportKeys: string[]): string;
+declare function getTextTypeLength(textType: TextProp["textType"]): number;
+declare function propToZodTypeDef(prop: EntityProp, injectImportKeys: string[]): string;
+declare function zodTypeToZodCode(zt: z.ZodFirstPartySchemaTypes | z.ZodObject<any>): string;
+declare function apiParamToTsCode(params: ApiParam[], injectImportKeys: string[]): string;
+declare function apiParamTypeToTsType(paramType: ApiParamType, injectImportKeys: string[]): string;
+declare function unwrapPromiseOnce(paramType: ApiParamType): ApiParamType;
+declare function serializeZodType(zt: z.ZodTypeAny): any;
+declare function zodTypeToTsTypeDef(zt: z.ZodFirstPartySchemaTypes | z.ZodObject<any>): string;
+
+interface ContextExtend {
+}
+type Context = {
+    reply: FastifyReply<Server, IncomingMessage, ServerResponse, RouteGenericInterface, unknown>;
+    headers: IncomingHttpHeaders;
+} & ContextExtend;
+
+declare class Entity {
+    id: string;
+    parentId?: string;
+    table: string;
+    title: string;
+    names: {
+        parentFs: string;
+        fs: string;
+        module: string;
+    };
+    props: EntityProp[];
+    propsDict: {
+        [key: string]: EntityProp;
+    };
+    relations: {
+        [key: string]: RelationProp;
+    };
+    indexes: EntityIndex[];
+    subsets: {
+        [key: string]: string[];
+    };
+    types: {
+        [name: string]: z.ZodTypeAny;
+    };
+    enums: {
+        [enumId: string]: z.ZodEnum<any>;
+    };
+    enumLabels: {
+        [enumId: string]: {
+            [key: string]: string;
+        };
+    };
+    constructor({ id, parentId, table, title, props, indexes, subsets, enums, }: EntityJson);
+    getSubsetQuery(subsetKey: string): SubsetQuery;
+    resolveSubsetQuery(prefix: string, fields: string[], isAlreadyOuterJoined?: boolean): SubsetQuery;
+    fieldExprsToPropNodes(fieldExprs: string[], entity?: Entity): EntityPropNode[];
+    getFieldExprs(prefix?: string, maxDepth?: number, froms?: string[]): string[];
+    getTableColumns(): string[];
+    registerModulePaths(): void;
+    registerTableSpecs(): void;
+    toJson(): EntityJson;
+    save(): Promise<void>;
+    getSubsetRows(_subsets?: {
+        [key: string]: string[];
+    }, prefixes?: string[]): EntitySubsetRow[];
+    subsetRowsToSubsetFields(subsetRows: EntitySubsetRow[], subsetKey: string): string[];
+    createProp(prop: EntityProp, at?: number): Promise<void>;
+    analyzeSubsetField(subsetField: string): {
+        entityId: string;
+        propName: string;
+    }[];
+    modifyProp(newProp: EntityProp, at: number): Promise<void>;
+    delProp(at: number): Promise<void>;
+    getEntityIdFromSubsetField(subsetField: string): string;
+    moveProp(at: number, to: number): Promise<void>;
+}
+
+type EntityNamesRecord = Record<"fs" | "fsPlural" | "camel" | "camelPlural" | "capital" | "capitalPlural" | "upper" | "constant", string>;
+type TableSpec = {
+    name: string;
+    uniqueIndexes: {
+        name?: string;
+        columns: string[];
+    }[];
+};
+declare class EntityManagerClass {
+    private entities;
+    modulePaths: Map<string, string>;
+    private tableSpecs;
+    isAutoloaded: boolean;
+    autoload(doSilent?: boolean): Promise<unknown>;
+    reload(doSilent?: boolean): Promise<unknown>;
+    register(json: EntityJson): void;
+    get(entityId: string): Entity;
+    exists(entityId: string): boolean;
+    getAllIds(): string[];
+    getAllParentIds(): string[];
+    getChildrenIds(parentId: string): string[];
+    setModulePath(key: string, modulePath: string): void;
+    getModulePath(key: string): string;
+    setTableSpec(tableSpec: TableSpec): void;
+    getTableSpec(key: string): TableSpec;
+    getNamesFromId(entityId: string): EntityNamesRecord;
+}
+declare const EntityManager: EntityManagerClass;
+
+declare abstract class Template {
+    key: TemplateKey;
+    constructor(key: TemplateKey);
+    abstract render(options: TemplateOptions[TemplateKey], ...extra: unknown[]): RenderedTemplate | Promise<RenderedTemplate>;
+    abstract getTargetAndPath(names?: EntityNamesRecord, ...extra: unknown[]): {
+        target: string;
+        path: string;
+    };
+}
+
+type PathAndChecksum = {
+    path: string;
+    checksum: string;
+};
+type RenderedTemplate = {
+    target: string;
+    path: string;
+    body: string;
+    importKeys: string[];
+    customHeaders?: string[];
+    preTemplates?: {
+        key: TemplateKey;
+        options: TemplateOptions[TemplateKey];
+    }[];
+};
+declare class Syncer {
+    apis: {
+        typeParameters: ApiParamType.TypeParam[];
+        parameters: ApiParam[];
+        returnType: ApiParamType;
+        modelName: string;
+        methodName: string;
+        path: string;
+        options: ApiDecoratorOptions;
+    }[];
+    types: {
+        [typeName: string]: z.ZodObject<any>;
+    };
+    models: {
+        [modelName: string]: unknown;
+    };
+    get checksumsPath(): string;
+    constructor();
+    sync(): Promise<void>;
+    getEntityIdFromPath(filePaths: string[]): string[];
+    actionGenerateSchemas(): Promise<string[]>;
+    actionGenerateServices(entityIds: string[]): Promise<string[]>;
+    actionGenerateHttps(entityIds: string[]): Promise<string[]>;
+    copyFileWithReplaceCoreToShared(fromPath: string, toPath: string): Promise<void>;
+    actionSyncFilesToTargets(tsPaths: string[]): Promise<string[]>;
+    getCurrentChecksums(): Promise<PathAndChecksum[]>;
+    getPreviousChecksums(): Promise<PathAndChecksum[]>;
+    saveChecksums(checksums: PathAndChecksum[]): Promise<void>;
+    getChecksumOfFile(filePath: string): Promise<string>;
+    readApisFromFile(filePath: string): Promise<{
+        typeParameters: ApiParamType.TypeParam[];
+        parameters: ApiParam[];
+        returnType: ApiParamType;
+        modelName: string;
+        methodName: string;
+        path: string;
+        options: ApiDecoratorOptions;
+    }[]>;
+    resolveTypeNode(typeNode: ts.TypeNode): ApiParamType;
+    resolveParamDec: (paramDec: {
+        name: ts.BindingName;
+        type: ts.TypeNode;
+        optional?: boolean;
+        defaultDef?: string;
+    }, index?: number) => ApiParam;
+    printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined;
+    autoloadApis(): Promise<{
+        typeParameters: ApiParamType.TypeParam[];
+        parameters: ApiParam[];
+        returnType: ApiParamType;
+        modelName: string;
+        methodName: string;
+        path: string;
+        options: ApiDecoratorOptions;
+    }[]>;
+    autoloadModels(): Promise<{
+        [modelName: string]: unknown;
+    }>;
+    autoloadTypes(doRefresh?: boolean): Promise<{
+        [typeName: string]: z.ZodObject<any>;
+    }>;
+    getTemplate(key: TemplateKey): Template;
+    renderTemplate<T extends keyof TemplateOptions>(key: T, options: TemplateOptions[T]): Promise<PathAndCode[]>;
+    resolveRenderedTemplate(key: TemplateKey, result: RenderedTemplate): Promise<PathAndCode>;
+    writeCodeToPath(pathAndCode: PathAndCode): Promise<string[]>;
+    generateTemplate(key: TemplateKey, templateOptions: any, _generateOptions?: GenerateOptions): Promise<string[][]>;
+    checkExistsGenCode(entityId: string, templateKey: TemplateKey, enumId?: string): {
+        subPath: string;
+        fullPath: string;
+        isExists: boolean;
+    };
+    checkExists(entityId: string, enums: {
+        [name: string]: z.ZodEnum<any>;
+    }): Record<`${TemplateKey}${string}`, boolean>;
+    getZodTypeById(zodTypeId: string): Promise<z.ZodTypeAny>;
+    propNodeToZodType(propNode: EntityPropNode): Promise<z.ZodTypeAny>;
+    propToZodType(prop: EntityProp): Promise<z.ZodTypeAny>;
+    resolveRenderType(key: string, zodType: z.ZodTypeAny): RenderingNode["renderType"];
+    zodTypeToRenderingNode(zodType: z.ZodTypeAny, baseKey?: string): RenderingNode;
+    getColumnsNode(entityId: string, subsetKey: string): Promise<RenderingNode>;
+    createEntity(form: Omit<TemplateOptions["entity"], "title"> & {
+        title?: string;
+    }): Promise<void>;
+    delEntity(entityId: string): Promise<{
+        delPaths: string[];
+    }>;
+}
+
+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 = {
+    api: {
+        dir: string;
+    };
+    sync: {
+        targets: string[];
+    };
+    route: {
+        prefix: string;
+    };
+};
+type SonamuSecrets = {
+    [key: string]: string;
+};
+type SonamuFastifyConfig = {
+    contextProvider: (defaultContext: Pick<Context, "headers" | "reply">, request: FastifyRequest, reply: FastifyReply) => Context;
+    guardHandler: (guard: string, request: FastifyRequest, api: {
+        typeParameters: ApiParamType.TypeParam[];
+        parameters: ApiParam[];
+        returnType: ApiParamType;
+        modelName: string;
+        methodName: string;
+        path: string;
+        options: ApiDecoratorOptions;
+    }) => void;
+    cache?: {
+        get: (key: string) => Promise<unknown | null>;
+        put: (key: string, value: unknown, ttl?: number) => Promise<void>;
+        resolveKey: (path: string, reqBody: {
+            [key: string]: unknown;
+        }) => {
+            cache: false;
+        } | {
+            cache: true;
+            key: string;
+            ttl?: number;
+        };
+    };
+};
+declare class SonamuClass {
+    isInitialized: boolean;
+    private _apiRootPath;
+    set apiRootPath(apiRootPath: string);
+    get apiRootPath(): string;
+    get appRootPath(): string;
+    private _dbConfig;
+    set dbConfig(dbConfig: SonamuDBConfig);
+    get dbConfig(): SonamuDBConfig;
+    private _syncer;
+    set syncer(syncer: Syncer);
+    get syncer(): Syncer;
+    private _config;
+    set config(config: SonamuConfig);
+    get config(): SonamuConfig;
+    private _secrets;
+    set secrets(secrets: SonamuSecrets);
+    get secrets(): SonamuSecrets | null;
+    init(doSilent?: boolean, enableSync?: boolean, apiRootPath?: string): Promise<void>;
+    withFastify(server: FastifyInstance<Server, IncomingMessage, ServerResponse>, config: SonamuFastifyConfig, options?: {
+        enableSync?: boolean;
+        doSilent?: boolean;
+    }): Promise<void>;
+    destroy(): Promise<void>;
+}
+declare const Sonamu: SonamuClass;
+
+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";
+}
+
+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 BaseModelClass {
+    modelName: string;
+    getDB(which: DBPreset): Knex;
+    destroy(): Promise<void>;
+    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 BaseModel: BaseModelClass;
+
+declare function setupErrorHandler(server: FastifyInstance): void;
+
+declare abstract class SoException extends Error {
+    readonly statusCode: number;
+    message: string;
+    payload?: unknown;
+    constructor(statusCode: number, message: string, payload?: unknown);
+}
+declare function isSoException(err: any): err is SoException;
+declare class BadRequestException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class UnauthorizedException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class NotFoundException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class ServiceUnavailableException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class InternalServerErrorException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class AlreadyProcessedException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class DuplicateRowException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+declare class TargetNotFoundException extends SoException {
+    message: string;
+    payload?: unknown;
+    constructor(message?: string, payload?: unknown);
+}
+
+declare const p: {
+    integer: typeof integer;
+    bigInteger: typeof bigInteger;
+    text: typeof text;
+    string: typeof string;
+    float: typeof float;
+    double: typeof double;
+    decimal: typeof decimal;
+    boolean: typeof boolean;
+    date: typeof date;
+    dateTime: typeof dateTime;
+    time: typeof time;
+    timestamp: typeof timestamp;
+    json: typeof json;
+    uuid: typeof uuid;
+    enums: typeof enums;
+    virtual: typeof virtual;
+    relationOneToOne: typeof relationOneToOne;
+    relationBelongsToOne: typeof relationBelongsToOne;
+    relationHasMany: typeof relationHasMany;
+    relationManyToMany: typeof relationManyToMany;
+};
+declare function integer(name: string, option?: Omit<IntegerProp, "name" | "type">): IntegerProp;
+declare function bigInteger(name: string, option?: Omit<BigIntegerProp, "name" | "type">): BigIntegerProp;
+declare function text(name: string, option: Omit<TextProp, "name" | "type">): TextProp;
+declare function string(name: string, option: Omit<StringProp, "name" | "type">): StringProp;
+declare function float(name: string, option?: Omit<FloatProp, "name" | "type">): FloatProp;
+declare function double(name: string, option?: Omit<DoubleProp, "name" | "type">): DoubleProp;
+declare function decimal(name: string, option?: Omit<DecimalProp, "name" | "type">): DecimalProp;
+declare function boolean(name: string, option?: Omit<BooleanProp, "name" | "type">): BooleanProp;
+declare function date(name: string, option?: Omit<DateProp, "name" | "type"> & {
+    now?: true;
+}): DateProp;
+declare function dateTime(name: string, option?: Omit<DateTimeProp, "name" | "type"> & {
+    now?: true;
+}): DateTimeProp;
+declare function time(name: string, option?: Omit<TimeProp, "name" | "type"> & {
+    now?: true;
+}): TimeProp;
+declare function timestamp(name: string, option?: Omit<TimestampProp, "name" | "type"> & {
+    now?: true;
+}): TimestampProp;
+declare function json(name: string, option: Omit<JsonProp, "name" | "type">): JsonProp;
+declare function uuid(name: string, option: Omit<UuidProp, "name" | "type">): UuidProp;
+declare function enums(name: string, option: Omit<EnumProp, "name" | "type" | "id"> & {
+    id?: string;
+}): EnumProp;
+declare function virtual(name: string, option: Omit<VirtualProp, "name" | "type" | "dbDefault" | "toFilter">): VirtualProp;
+declare function relationOneToOne(name: string, option: DistributiveOmit<OneToOneRelationProp, "name" | "type" | "relationType">): OneToOneRelationProp;
+declare function relationBelongsToOne(name: string, option: Omit<BelongsToOneRelationProp, "name" | "type" | "relationType">): BelongsToOneRelationProp;
+declare function relationHasMany(name: string, option: Omit<HasManyRelationProp, "name" | "type" | "relationType">): HasManyRelationProp;
+declare function relationManyToMany(name: string, option: Omit<ManyToManyRelationProp, "name" | "type" | "relationType">): ManyToManyRelationProp;
+declare const i: {
+    index: typeof index;
+    unique: typeof unique;
+};
+declare function index(columns: string | string[]): EntityIndex;
+declare function unique(columns: string | string[]): EntityIndex;
+
+type MigratorMode = "dev" | "deploy";
+type MigratorOptions = {
+    readonly mode: MigratorMode;
+};
+type MigrationCode = {
+    name: string;
+    path: string;
+};
+type ConnString = `${"mysql2"}://${string}@${string}:${number}/${string}`;
+type MigrationStatus = {
+    codes: MigrationCode[];
+    conns: {
+        name: string;
+        connKey: string;
+        connString: ConnString;
+        currentVersion: string;
+        status: string | number;
+        pending: string[];
+    }[];
+    preparedCodes: GenMigrationCode[];
+};
+declare class Migrator {
+    readonly mode: MigratorMode;
+    targets: {
+        compare?: Knex;
+        pending: Knex;
+        shadow: Knex;
+        apply: Knex[];
+    };
+    constructor(options: MigratorOptions);
+    getMigrationCodes(): Promise<{
+        normal: MigrationCode[];
+        onlyTs: MigrationCode[];
+        onlyJs: MigrationCode[];
+    }>;
+    getStatus(): Promise<MigrationStatus>;
+    runAction(action: "latest" | "rollback", targets: string[]): Promise<{
+        connKey: string;
+        batchNo: number;
+        applied: string[];
+    }[]>;
+    delCodes(codeNames: string[]): Promise<number>;
+    generatePreparedCodes(): Promise<number>;
+    clearPendingList(): Promise<void>;
+    check(): Promise<void>;
+    run(): Promise<void>;
+    rollback(): Promise<void>;
+    cleanUpDist(force?: boolean): Promise<void>;
+    runShadowTest(): Promise<{
+        connKey: string;
+        batchNo: number;
+        applied: string[];
+    }[]>;
+    resetAll(): Promise<void>;
+    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: 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 = {
+    Field: string;
+    Type: string;
+    Null: string;
+    Key: string;
+    Default: string | null;
+    Extra: string;
+};
+type DBIndex = {
+    Table: string;
+    Non_unique: number;
+    Key_name: string;
+    Seq_in_index: number;
+    Column_name: string;
+    Collation: string | null;
+    Cardinality: number | null;
+    Sub_part: number | null;
+    Packed: string | null;
+    Null: string;
+    Index_type: string;
+    Comment: string;
+    Index_comment: string;
+    Visible: string;
+    Expression: string | null;
+};
+type DBForeign = {
+    keyName: string;
+    from: string;
+    referencesTable: string;
+    referencesField: string;
+    onDelete: string;
+    onUpdate: string;
+};
+
+declare class FixtureManagerClass {
+    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: Knex, tableName: string): Promise<any>;
+    sync(): Promise<void>;
+    importFixture(entityId: string, ids: number[]): Promise<void>;
+    getImportQueries(entityId: string, field: string, id: number): Promise<string[]>;
+    destory(): Promise<void>;
+    getFixtures(sourceDBName: keyof SonamuDBConfig, targetDBName: keyof SonamuDBConfig, searchOptions: FixtureSearchOptions): Promise<FixtureRecord[]>;
+    createFixtureRecord(entity: Entity, row: any, options?: {
+        singleRecord?: boolean;
+        _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>;
+    private checkUniqueViolation;
+}
+declare const FixtureManager: FixtureManagerClass;
+
+declare function isLocal(): boolean;
+declare function isRemote(): boolean;
+declare function isInDocker(): boolean;
+declare function isDaemonServer(): boolean;
+declare function isDevelopment(): boolean;
+declare function isStaging(): boolean;
+declare function isProduction(): boolean;
+declare function isTest(): boolean;
+
+declare function globAsync(pathPattern: string): Promise<string[]>;
+declare function importMultiple(filePaths: string[], doRefresh?: boolean): Promise<{
+    filePath: string;
+    imported: any;
+}[]>;
+declare function findAppRootPath(): Promise<string>;
+declare function findApiRootPath(): Promise<string>;
+declare function nonNullable<T>(value: T): value is NonNullable<T>;
+
+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 };