import type { CreateUserPayload } from "./auth/AppAuth";
import { Event } from "./core/events";
import type { em as prototypeEm } from "./data/prototype";
import { Connection } from "./data/connection/Connection";
import type { Hono } from "hono";
import { ModuleManager, type InitialModuleConfigs, type ModuleBuildContext, type ModuleConfigs, type ModuleManagerOptions, type Modules } from "./modules/ModuleManager";
import { AdminController, type AdminControllerOptions } from "./modules/server/AdminController";
import type { MaybePromise } from "./core/types";
import type { ServerEnv } from "./modules/Controller";
import type { IEmailDriver, ICacheDriver } from "./core/drivers";
import { Api, type ApiOptions } from "./Api";
export type AppPluginConfig = {
    name: string;
    schema?: () => MaybePromise<ReturnType<typeof prototypeEm> | void>;
    beforeBuild?: () => MaybePromise<void>;
    onBuilt?: () => MaybePromise<void>;
    onServerInit?: (server: Hono<ServerEnv>) => MaybePromise<void>;
    onFirstBoot?: () => MaybePromise<void>;
    onBoot?: () => MaybePromise<void>;
};
export type AppPlugin = (app: App) => AppPluginConfig;
declare abstract class AppEvent<A = {}> extends Event<{
    app: App;
} & A> {
}
export declare class AppConfigUpdatedEvent extends AppEvent<{
    module: string;
    config: ModuleConfigs[keyof ModuleConfigs];
}> {
    static slug: string;
}
/**
 * @type {Event<{ app: App }>}
 */
export declare class AppBuiltEvent extends AppEvent {
    static slug: string;
}
export declare class AppFirstBoot extends AppEvent {
    static slug: string;
}
export declare class AppRequest extends AppEvent<{
    request: Request;
}> {
    static slug: string;
}
export declare class AppBeforeResponse extends AppEvent<{
    request: Request;
    response: Response;
}> {
    static slug: string;
}
export declare const AppEvents: {
    readonly AppConfigUpdatedEvent: typeof AppConfigUpdatedEvent;
    readonly AppBuiltEvent: typeof AppBuiltEvent;
    readonly AppFirstBoot: typeof AppFirstBoot;
    readonly AppRequest: typeof AppRequest;
    readonly AppBeforeResponse: typeof AppBeforeResponse;
};
export type AppOptions = {
    plugins?: AppPlugin[];
    seed?: (ctx: ModuleBuildContext & {
        app: App;
    }) => Promise<void>;
    manager?: Omit<ModuleManagerOptions, "initial" | "onUpdated" | "seed">;
    asyncEventsMode?: "sync" | "async" | "none";
    drivers?: {
        email?: IEmailDriver;
        cache?: ICacheDriver;
    };
};
export type CreateAppConfig = {
    /**
     * bla
     */
    connection?: Connection | {
        url: string;
    };
    initialConfig?: InitialModuleConfigs;
    options?: AppOptions;
};
export type AppConfig = InitialModuleConfigs;
export type LocalApiOptions = Request | ApiOptions;
export declare class App<C extends Connection = Connection, Options extends AppOptions = AppOptions> {
    connection: C;
    private options?;
    static readonly Events: {
        readonly AppConfigUpdatedEvent: typeof AppConfigUpdatedEvent;
        readonly AppBuiltEvent: typeof AppBuiltEvent;
        readonly AppFirstBoot: typeof AppFirstBoot;
        readonly AppRequest: typeof AppRequest;
        readonly AppBeforeResponse: typeof AppBeforeResponse;
    };
    modules: ModuleManager;
    adminController?: AdminController;
    _id: string;
    plugins: Map<string, AppPluginConfig>;
    drivers: Options["drivers"];
    private trigger_first_boot;
    private _building;
    constructor(connection: C, _initialConfig?: InitialModuleConfigs, options?: Options | undefined);
    get emgr(): import(".").EventManager<any>;
    protected runPlugins<Key extends keyof AppPluginConfig>(key: Key, ...args: any[]): Promise<{
        name: string;
        result: any;
    }[]>;
    build(options?: {
        sync?: boolean;
        fetch?: boolean;
        forceBuild?: boolean;
    }): Promise<void>;
    mutateConfig<Module extends keyof Modules>(module: Module): Pick<ReturnType<Modules[Module]["schema"]>, "patch" | "overwrite" | "set" | "remove">;
    get server(): Hono<ServerEnv, import("hono/types").BlankSchema, "/">;
    get em(): import(".").EntityManager<import(".").DB>;
    get fetch(): Hono["fetch"];
    get module(): Modules;
    getSchema(): {
        server: import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/auth";
            }> & {
                readonly default: "/api/auth";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "users";
            }> & {
                readonly default: "users";
            };
            readonly allow_register: {
                readonly default: true;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
            readonly jwt: import("jsonv-ts").ObjectSchema<{
                readonly secret: import("./core/utils").SecretSchema<{
                    default: string;
                }> & {
                    default: string;
                };
                readonly alg: {
                    readonly default: "HS256";
                    readonly enum: ["HS256", "HS384", "HS512"];
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "HS256" | "HS384" | "HS512" | undefined, "HS256" | "HS384" | "HS512" | undefined>;
                readonly expires: {
                    default?: any;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                    multipleOf?: number | undefined;
                    maximum?: number | undefined;
                    exclusiveMaximum?: number | undefined;
                    minimum?: number | undefined;
                    exclusiveMinimum?: number | undefined;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly issuer: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["id", "email", "role"];
                }> & {
                    readonly default: readonly ["id", "email", "role"];
                };
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly cookie: import("jsonv-ts").ObjectSchema<{
                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly sameSite: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "strict" | "lax" | "none" | undefined, "strict" | "lax" | "none" | undefined>;
                readonly secure: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly httpOnly: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly expires: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly partitioned: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly renew: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly pathSuccess: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly pathLoggedOut: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
            readonly strategies: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                enabled?: boolean | undefined;
                type: "password" | "oauth" | "custom_oauth";
                config: {
                    rounds?: number | undefined;
                    hashing: "plain" | "sha256" | "bcrypt";
                } | {
                    [x: string]: unknown;
                    name: "google" | "github";
                    type: "oidc" | "oauth2";
                    client: {
                        client_id: string;
                        client_secret: string;
                    };
                } | {
                    name: string;
                    type: "oidc" | "oauth2";
                    client: {
                        [x: string]: unknown;
                        client_id: string;
                        client_secret: string;
                        token_endpoint_auth_method: "client_secret_basic";
                    };
                    as: {
                        code_challenge_methods_supported?: "S256" | undefined;
                        scopes_supported?: string[] | undefined;
                        scope_separator?: string | undefined;
                        authorization_endpoint?: string | undefined;
                        token_endpoint?: string | undefined;
                        userinfo_endpoint?: string | undefined;
                        issuer: string;
                    };
                };
            }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: true;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "password" | "oauth" | "custom_oauth", "password" | "oauth" | "custom_oauth"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: "password" | "oauth" | "custom_oauth";
                    }>;
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly hashing: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        }> & {
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        };
                        readonly rounds: {
                            readonly maximum: 10;
                            readonly minimum: 1;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>> | (import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").StringSchema<{
                            readonly enum: ("google" | "github")[];
                        }> & {
                            readonly enum: ("google" | "github")[];
                        };
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        };
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, {
                        readonly title: "OAuth";
                    }> & {
                        readonly title: "OAuth";
                    }) | import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        };
                        readonly name: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly token_endpoint_auth_method: import("jsonv-ts").StringSchema<{
                                readonly enum: readonly ["client_secret_basic"];
                            }> & {
                                readonly enum: readonly ["client_secret_basic"];
                            };
                        }, import("jsonv-ts").IObjectOptions> & import("jsonv-ts").IObjectOptions;
                        readonly as: import("jsonv-ts").ObjectSchema<{
                            readonly issuer: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly code_challenge_methods_supported: {
                                readonly enum: ["S256"];
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "S256" | undefined, "S256" | undefined>;
                            readonly scopes_supported: {
                                default?: any;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                contains?: import("jsonv-ts").Schema | undefined;
                                minContains?: number | undefined;
                                maxContains?: number | undefined;
                                prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                uniqueItems?: boolean | undefined;
                                maxItems?: number | undefined;
                                minItems?: number | undefined;
                                readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                            readonly scope_separator: {
                                readonly default: " ";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly authorization_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly token_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly userinfo_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<{
                        readonly title: "Custom OAuth";
                    } & {
                        additionalProperties: false;
                    }>>;
                }, import("jsonv-ts").Merge<{
                    readonly title: "password" | "oauth" | "custom_oauth";
                } & {
                    additionalProperties: false;
                }>>[];
            }>, {
                readonly title: "Strategies";
                readonly default: {
                    readonly password: {
                        readonly type: "password";
                        readonly enabled: true;
                        readonly config: {
                            readonly hashing: "sha256";
                        };
                    };
                };
            }>;
            readonly guard: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                minProperties?: number | undefined;
                maxProperties?: number | undefined;
                propertyNames?: import("jsonv-ts").Schema | undefined;
                strict: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
                properties: {
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                };
                required: string[] | undefined;
                partial: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").IObjectOptions>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined>;
            readonly roles: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly permissions: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                        contains?: import("jsonv-ts").Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: import("jsonv-ts").Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                    readonly is_default: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly implicit_allow: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly title: "Authentication";
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly cors: import("jsonv-ts").ObjectSchema<{
                readonly origin: import("jsonv-ts").StringSchema<{
                    readonly default: "*";
                }> & {
                    readonly default: "*";
                };
                readonly allow_methods: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }> & {
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }, {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                }> & {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                };
                readonly allow_headers: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                }> & {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                };
                readonly allow_credentials: import("jsonv-ts").Schema<{
                    readonly default: true;
                }, boolean, boolean> & {
                    readonly default: true;
                };
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: {
                readonly default: "/api/data";
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            readonly default_primary_format: {
                readonly default: "integer";
                readonly enum: readonly ["integer", "uuid"];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
            readonly entities: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly name: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                    readonly type: import("jsonv-ts").StringSchema<{
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    }> & {
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    };
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly name_singular: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_dir: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "asc" | "desc" | undefined, "asc" | "desc" | undefined>;
                        readonly primary_format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                    readonly fields: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        name?: string | undefined;
                        config?: {
                            description?: string | undefined;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            html_config?: {
                                [x: string]: unknown;
                                element?: string | undefined;
                                props?: {
                                    [x: string]: string | number;
                                } | undefined;
                            } | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            format?: "integer" | "uuid" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                            required?: boolean | undefined;
                            default_value?: number | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: boolean | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            type?: "date" | "week" | "datetime" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            timezone?: string | undefined;
                            min_date?: string | undefined;
                            max_date?: string | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            options?: {
                                [x: string]: unknown;
                                values: string[];
                                type: "strings";
                            } | {
                                [x: string]: unknown;
                                values: {
                                    [x: string]: unknown;
                                    value: string;
                                    label: string;
                                }[];
                                type: "objects";
                            } | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            schema?: any;
                            ui_schema?: any;
                            default_from_schema?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            target_field?: string | undefined;
                            target_field_type?: "text" | "integer" | undefined;
                            on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                            reference: string;
                            target: string;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            entity?: string | undefined;
                            min_items?: number | undefined;
                            max_items?: number | undefined;
                            mime_types?: string[] | undefined;
                        } | undefined;
                        type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly name: {
                                default?: any;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: (string | RegExp) | undefined;
                                format?: string | undefined;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema", "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                            }>;
                            readonly config: ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: any;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined>);
                        }, import("jsonv-ts").Merge<{
                            readonly title: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>, import("jsonv-ts").IRecordOptions>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: {
                            name?: string | undefined;
                            config?: {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined;
                            type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        };
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: never;
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined>;
            readonly relations: {
                additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: string;
                        }>;
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                };
            } | undefined, {
                [x: string]: never;
            } | undefined>;
            readonly indices: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly entity: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                    readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                        readonly minItems: 1;
                    }> & {
                        readonly minItems: 1;
                    };
                    readonly unique: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/media";
            }> & {
                readonly default: "/api/media";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "media";
            }> & {
                readonly default: "media";
            };
            readonly storage: import("jsonv-ts").ObjectSchema<{
                readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly adapter: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: string;
                    }>;
                    readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
                }, import("jsonv-ts").Merge<{
                    readonly title: string;
                    readonly description: string | undefined;
                } & {
                    additionalProperties: false;
                }>>[];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                config?: unknown;
                type: string;
            } | undefined, never>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/flows";
            }> & {
                readonly default: "/api/flows";
            };
            readonly flows: import("jsonv-ts").RecordSchema<import("jsonv-ts").ObjectSchema<{
                readonly trigger: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        mode: "sync" | "async";
                    } | {
                        event: string;
                        mode: "sync" | "async";
                    } | {
                        path: string;
                        mode: "sync" | "async";
                        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                        response_type: "html" | "json" | "text";
                    } | undefined;
                    type: "manual" | "event" | "http";
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: "manual" | "event" | "http";
                        }>;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            mode: "sync" | "async";
                        } | undefined, {
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly event: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly method: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                                readonly response_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
                readonly tasks: {
                    additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "log" | "fetch" | "render" | "subflow";
                            }>;
                            readonly params: import("jsonv-ts").ObjectSchema<{
                                readonly url: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^(http|https)://";
                                }> & {
                                    readonly pattern: "^(http|https)://";
                                };
                                readonly method: {
                                    readonly default: "GET";
                                    readonly enum: string[];
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly headers: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    contains?: import("jsonv-ts").Schema | undefined;
                                    minContains?: number | undefined;
                                    maxContains?: number | undefined;
                                    prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                    uniqueItems?: boolean | undefined;
                                    maxItems?: number | undefined;
                                    minItems?: number | undefined;
                                    readonly items?: import("jsonv-ts").ObjectSchema<{
                                        readonly key: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                        readonly value: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>> | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    key: string;
                                    value: string;
                                }[] | undefined, {
                                    key: string;
                                    value: string;
                                }[] | undefined>;
                                readonly body: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly normal: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly delay: import("jsonv-ts").Schema<{
                                    readonly default: 10;
                                }, number, number> & {
                                    readonly default: 10;
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly render: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly flow: import("jsonv-ts").Schema<import("jsonv-ts").IAnyOptions, any, any> & import("jsonv-ts").IAnyOptions;
                                readonly input: {
                                    [x: string]: any;
                                    [x: number]: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                readonly loop: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        }, import("jsonv-ts").Merge<{
                            readonly title: string;
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    };
                } | undefined, {
                    [x: string]: never;
                } | undefined>;
                readonly connections: {
                    additionalProperties: import("jsonv-ts").ObjectSchema<{
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: import("jsonv-ts").ObjectSchema<{
                            readonly condition: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined, {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined>;
                            readonly max_retries: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined>;
                readonly start_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly responding_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>, {
                readonly default: {};
            }>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>>;
        data: import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/auth";
            }> & {
                readonly default: "/api/auth";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "users";
            }> & {
                readonly default: "users";
            };
            readonly allow_register: {
                readonly default: true;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
            readonly jwt: import("jsonv-ts").ObjectSchema<{
                readonly secret: import("./core/utils").SecretSchema<{
                    default: string;
                }> & {
                    default: string;
                };
                readonly alg: {
                    readonly default: "HS256";
                    readonly enum: ["HS256", "HS384", "HS512"];
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "HS256" | "HS384" | "HS512" | undefined, "HS256" | "HS384" | "HS512" | undefined>;
                readonly expires: {
                    default?: any;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                    multipleOf?: number | undefined;
                    maximum?: number | undefined;
                    exclusiveMaximum?: number | undefined;
                    minimum?: number | undefined;
                    exclusiveMinimum?: number | undefined;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly issuer: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["id", "email", "role"];
                }> & {
                    readonly default: readonly ["id", "email", "role"];
                };
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly cookie: import("jsonv-ts").ObjectSchema<{
                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly sameSite: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "strict" | "lax" | "none" | undefined, "strict" | "lax" | "none" | undefined>;
                readonly secure: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly httpOnly: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly expires: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly partitioned: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly renew: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly pathSuccess: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly pathLoggedOut: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
            readonly strategies: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                enabled?: boolean | undefined;
                type: "password" | "oauth" | "custom_oauth";
                config: {
                    rounds?: number | undefined;
                    hashing: "plain" | "sha256" | "bcrypt";
                } | {
                    [x: string]: unknown;
                    name: "google" | "github";
                    type: "oidc" | "oauth2";
                    client: {
                        client_id: string;
                        client_secret: string;
                    };
                } | {
                    name: string;
                    type: "oidc" | "oauth2";
                    client: {
                        [x: string]: unknown;
                        client_id: string;
                        client_secret: string;
                        token_endpoint_auth_method: "client_secret_basic";
                    };
                    as: {
                        code_challenge_methods_supported?: "S256" | undefined;
                        scopes_supported?: string[] | undefined;
                        scope_separator?: string | undefined;
                        authorization_endpoint?: string | undefined;
                        token_endpoint?: string | undefined;
                        userinfo_endpoint?: string | undefined;
                        issuer: string;
                    };
                };
            }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: true;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "password" | "oauth" | "custom_oauth", "password" | "oauth" | "custom_oauth"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: "password" | "oauth" | "custom_oauth";
                    }>;
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly hashing: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        }> & {
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        };
                        readonly rounds: {
                            readonly maximum: 10;
                            readonly minimum: 1;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>> | (import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").StringSchema<{
                            readonly enum: ("google" | "github")[];
                        }> & {
                            readonly enum: ("google" | "github")[];
                        };
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        };
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, {
                        readonly title: "OAuth";
                    }> & {
                        readonly title: "OAuth";
                    }) | import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        };
                        readonly name: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly token_endpoint_auth_method: import("jsonv-ts").StringSchema<{
                                readonly enum: readonly ["client_secret_basic"];
                            }> & {
                                readonly enum: readonly ["client_secret_basic"];
                            };
                        }, import("jsonv-ts").IObjectOptions> & import("jsonv-ts").IObjectOptions;
                        readonly as: import("jsonv-ts").ObjectSchema<{
                            readonly issuer: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly code_challenge_methods_supported: {
                                readonly enum: ["S256"];
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "S256" | undefined, "S256" | undefined>;
                            readonly scopes_supported: {
                                default?: any;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                contains?: import("jsonv-ts").Schema | undefined;
                                minContains?: number | undefined;
                                maxContains?: number | undefined;
                                prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                uniqueItems?: boolean | undefined;
                                maxItems?: number | undefined;
                                minItems?: number | undefined;
                                readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                            readonly scope_separator: {
                                readonly default: " ";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly authorization_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly token_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly userinfo_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<{
                        readonly title: "Custom OAuth";
                    } & {
                        additionalProperties: false;
                    }>>;
                }, import("jsonv-ts").Merge<{
                    readonly title: "password" | "oauth" | "custom_oauth";
                } & {
                    additionalProperties: false;
                }>>[];
            }>, {
                readonly title: "Strategies";
                readonly default: {
                    readonly password: {
                        readonly type: "password";
                        readonly enabled: true;
                        readonly config: {
                            readonly hashing: "sha256";
                        };
                    };
                };
            }>;
            readonly guard: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                minProperties?: number | undefined;
                maxProperties?: number | undefined;
                propertyNames?: import("jsonv-ts").Schema | undefined;
                strict: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
                properties: {
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                };
                required: string[] | undefined;
                partial: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").IObjectOptions>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined>;
            readonly roles: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly permissions: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                        contains?: import("jsonv-ts").Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: import("jsonv-ts").Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                    readonly is_default: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly implicit_allow: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly title: "Authentication";
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly cors: import("jsonv-ts").ObjectSchema<{
                readonly origin: import("jsonv-ts").StringSchema<{
                    readonly default: "*";
                }> & {
                    readonly default: "*";
                };
                readonly allow_methods: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }> & {
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }, {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                }> & {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                };
                readonly allow_headers: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                }> & {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                };
                readonly allow_credentials: import("jsonv-ts").Schema<{
                    readonly default: true;
                }, boolean, boolean> & {
                    readonly default: true;
                };
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: {
                readonly default: "/api/data";
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            readonly default_primary_format: {
                readonly default: "integer";
                readonly enum: readonly ["integer", "uuid"];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
            readonly entities: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly name: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                    readonly type: import("jsonv-ts").StringSchema<{
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    }> & {
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    };
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly name_singular: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_dir: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "asc" | "desc" | undefined, "asc" | "desc" | undefined>;
                        readonly primary_format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                    readonly fields: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        name?: string | undefined;
                        config?: {
                            description?: string | undefined;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            html_config?: {
                                [x: string]: unknown;
                                element?: string | undefined;
                                props?: {
                                    [x: string]: string | number;
                                } | undefined;
                            } | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            format?: "integer" | "uuid" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                            required?: boolean | undefined;
                            default_value?: number | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: boolean | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            type?: "date" | "week" | "datetime" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            timezone?: string | undefined;
                            min_date?: string | undefined;
                            max_date?: string | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            options?: {
                                [x: string]: unknown;
                                values: string[];
                                type: "strings";
                            } | {
                                [x: string]: unknown;
                                values: {
                                    [x: string]: unknown;
                                    value: string;
                                    label: string;
                                }[];
                                type: "objects";
                            } | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            schema?: any;
                            ui_schema?: any;
                            default_from_schema?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            target_field?: string | undefined;
                            target_field_type?: "text" | "integer" | undefined;
                            on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                            reference: string;
                            target: string;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            entity?: string | undefined;
                            min_items?: number | undefined;
                            max_items?: number | undefined;
                            mime_types?: string[] | undefined;
                        } | undefined;
                        type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly name: {
                                default?: any;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: (string | RegExp) | undefined;
                                format?: string | undefined;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema", "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                            }>;
                            readonly config: ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: any;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined>);
                        }, import("jsonv-ts").Merge<{
                            readonly title: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>, import("jsonv-ts").IRecordOptions>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: {
                            name?: string | undefined;
                            config?: {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined;
                            type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        };
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: never;
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined>;
            readonly relations: {
                additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: string;
                        }>;
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                };
            } | undefined, {
                [x: string]: never;
            } | undefined>;
            readonly indices: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly entity: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                    readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                        readonly minItems: 1;
                    }> & {
                        readonly minItems: 1;
                    };
                    readonly unique: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/media";
            }> & {
                readonly default: "/api/media";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "media";
            }> & {
                readonly default: "media";
            };
            readonly storage: import("jsonv-ts").ObjectSchema<{
                readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly adapter: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: string;
                    }>;
                    readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
                }, import("jsonv-ts").Merge<{
                    readonly title: string;
                    readonly description: string | undefined;
                } & {
                    additionalProperties: false;
                }>>[];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                config?: unknown;
                type: string;
            } | undefined, never>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/flows";
            }> & {
                readonly default: "/api/flows";
            };
            readonly flows: import("jsonv-ts").RecordSchema<import("jsonv-ts").ObjectSchema<{
                readonly trigger: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        mode: "sync" | "async";
                    } | {
                        event: string;
                        mode: "sync" | "async";
                    } | {
                        path: string;
                        mode: "sync" | "async";
                        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                        response_type: "html" | "json" | "text";
                    } | undefined;
                    type: "manual" | "event" | "http";
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: "manual" | "event" | "http";
                        }>;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            mode: "sync" | "async";
                        } | undefined, {
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly event: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly method: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                                readonly response_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
                readonly tasks: {
                    additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "log" | "fetch" | "render" | "subflow";
                            }>;
                            readonly params: import("jsonv-ts").ObjectSchema<{
                                readonly url: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^(http|https)://";
                                }> & {
                                    readonly pattern: "^(http|https)://";
                                };
                                readonly method: {
                                    readonly default: "GET";
                                    readonly enum: string[];
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly headers: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    contains?: import("jsonv-ts").Schema | undefined;
                                    minContains?: number | undefined;
                                    maxContains?: number | undefined;
                                    prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                    uniqueItems?: boolean | undefined;
                                    maxItems?: number | undefined;
                                    minItems?: number | undefined;
                                    readonly items?: import("jsonv-ts").ObjectSchema<{
                                        readonly key: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                        readonly value: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>> | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    key: string;
                                    value: string;
                                }[] | undefined, {
                                    key: string;
                                    value: string;
                                }[] | undefined>;
                                readonly body: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly normal: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly delay: import("jsonv-ts").Schema<{
                                    readonly default: 10;
                                }, number, number> & {
                                    readonly default: 10;
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly render: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly flow: import("jsonv-ts").Schema<import("jsonv-ts").IAnyOptions, any, any> & import("jsonv-ts").IAnyOptions;
                                readonly input: {
                                    [x: string]: any;
                                    [x: number]: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                readonly loop: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        }, import("jsonv-ts").Merge<{
                            readonly title: string;
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    };
                } | undefined, {
                    [x: string]: never;
                } | undefined>;
                readonly connections: {
                    additionalProperties: import("jsonv-ts").ObjectSchema<{
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: import("jsonv-ts").ObjectSchema<{
                            readonly condition: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined, {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined>;
                            readonly max_retries: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined>;
                readonly start_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly responding_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>, {
                readonly default: {};
            }>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>>;
        auth: import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/auth";
            }> & {
                readonly default: "/api/auth";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "users";
            }> & {
                readonly default: "users";
            };
            readonly allow_register: {
                readonly default: true;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
            readonly jwt: import("jsonv-ts").ObjectSchema<{
                readonly secret: import("./core/utils").SecretSchema<{
                    default: string;
                }> & {
                    default: string;
                };
                readonly alg: {
                    readonly default: "HS256";
                    readonly enum: ["HS256", "HS384", "HS512"];
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "HS256" | "HS384" | "HS512" | undefined, "HS256" | "HS384" | "HS512" | undefined>;
                readonly expires: {
                    default?: any;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                    multipleOf?: number | undefined;
                    maximum?: number | undefined;
                    exclusiveMaximum?: number | undefined;
                    minimum?: number | undefined;
                    exclusiveMinimum?: number | undefined;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly issuer: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["id", "email", "role"];
                }> & {
                    readonly default: readonly ["id", "email", "role"];
                };
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly cookie: import("jsonv-ts").ObjectSchema<{
                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly sameSite: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "strict" | "lax" | "none" | undefined, "strict" | "lax" | "none" | undefined>;
                readonly secure: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly httpOnly: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly expires: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly partitioned: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly renew: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly pathSuccess: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly pathLoggedOut: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
            readonly strategies: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                enabled?: boolean | undefined;
                type: "password" | "oauth" | "custom_oauth";
                config: {
                    rounds?: number | undefined;
                    hashing: "plain" | "sha256" | "bcrypt";
                } | {
                    [x: string]: unknown;
                    name: "google" | "github";
                    type: "oidc" | "oauth2";
                    client: {
                        client_id: string;
                        client_secret: string;
                    };
                } | {
                    name: string;
                    type: "oidc" | "oauth2";
                    client: {
                        [x: string]: unknown;
                        client_id: string;
                        client_secret: string;
                        token_endpoint_auth_method: "client_secret_basic";
                    };
                    as: {
                        code_challenge_methods_supported?: "S256" | undefined;
                        scopes_supported?: string[] | undefined;
                        scope_separator?: string | undefined;
                        authorization_endpoint?: string | undefined;
                        token_endpoint?: string | undefined;
                        userinfo_endpoint?: string | undefined;
                        issuer: string;
                    };
                };
            }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: true;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "password" | "oauth" | "custom_oauth", "password" | "oauth" | "custom_oauth"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: "password" | "oauth" | "custom_oauth";
                    }>;
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly hashing: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        }> & {
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        };
                        readonly rounds: {
                            readonly maximum: 10;
                            readonly minimum: 1;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>> | (import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").StringSchema<{
                            readonly enum: ("google" | "github")[];
                        }> & {
                            readonly enum: ("google" | "github")[];
                        };
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        };
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, {
                        readonly title: "OAuth";
                    }> & {
                        readonly title: "OAuth";
                    }) | import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        };
                        readonly name: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly token_endpoint_auth_method: import("jsonv-ts").StringSchema<{
                                readonly enum: readonly ["client_secret_basic"];
                            }> & {
                                readonly enum: readonly ["client_secret_basic"];
                            };
                        }, import("jsonv-ts").IObjectOptions> & import("jsonv-ts").IObjectOptions;
                        readonly as: import("jsonv-ts").ObjectSchema<{
                            readonly issuer: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly code_challenge_methods_supported: {
                                readonly enum: ["S256"];
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "S256" | undefined, "S256" | undefined>;
                            readonly scopes_supported: {
                                default?: any;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                contains?: import("jsonv-ts").Schema | undefined;
                                minContains?: number | undefined;
                                maxContains?: number | undefined;
                                prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                uniqueItems?: boolean | undefined;
                                maxItems?: number | undefined;
                                minItems?: number | undefined;
                                readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                            readonly scope_separator: {
                                readonly default: " ";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly authorization_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly token_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly userinfo_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<{
                        readonly title: "Custom OAuth";
                    } & {
                        additionalProperties: false;
                    }>>;
                }, import("jsonv-ts").Merge<{
                    readonly title: "password" | "oauth" | "custom_oauth";
                } & {
                    additionalProperties: false;
                }>>[];
            }>, {
                readonly title: "Strategies";
                readonly default: {
                    readonly password: {
                        readonly type: "password";
                        readonly enabled: true;
                        readonly config: {
                            readonly hashing: "sha256";
                        };
                    };
                };
            }>;
            readonly guard: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                minProperties?: number | undefined;
                maxProperties?: number | undefined;
                propertyNames?: import("jsonv-ts").Schema | undefined;
                strict: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
                properties: {
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                };
                required: string[] | undefined;
                partial: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").IObjectOptions>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined>;
            readonly roles: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly permissions: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                        contains?: import("jsonv-ts").Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: import("jsonv-ts").Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                    readonly is_default: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly implicit_allow: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly title: "Authentication";
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly cors: import("jsonv-ts").ObjectSchema<{
                readonly origin: import("jsonv-ts").StringSchema<{
                    readonly default: "*";
                }> & {
                    readonly default: "*";
                };
                readonly allow_methods: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }> & {
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }, {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                }> & {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                };
                readonly allow_headers: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                }> & {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                };
                readonly allow_credentials: import("jsonv-ts").Schema<{
                    readonly default: true;
                }, boolean, boolean> & {
                    readonly default: true;
                };
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: {
                readonly default: "/api/data";
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            readonly default_primary_format: {
                readonly default: "integer";
                readonly enum: readonly ["integer", "uuid"];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
            readonly entities: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly name: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                    readonly type: import("jsonv-ts").StringSchema<{
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    }> & {
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    };
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly name_singular: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_dir: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "asc" | "desc" | undefined, "asc" | "desc" | undefined>;
                        readonly primary_format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                    readonly fields: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        name?: string | undefined;
                        config?: {
                            description?: string | undefined;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            html_config?: {
                                [x: string]: unknown;
                                element?: string | undefined;
                                props?: {
                                    [x: string]: string | number;
                                } | undefined;
                            } | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            format?: "integer" | "uuid" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                            required?: boolean | undefined;
                            default_value?: number | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: boolean | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            type?: "date" | "week" | "datetime" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            timezone?: string | undefined;
                            min_date?: string | undefined;
                            max_date?: string | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            options?: {
                                [x: string]: unknown;
                                values: string[];
                                type: "strings";
                            } | {
                                [x: string]: unknown;
                                values: {
                                    [x: string]: unknown;
                                    value: string;
                                    label: string;
                                }[];
                                type: "objects";
                            } | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            schema?: any;
                            ui_schema?: any;
                            default_from_schema?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            target_field?: string | undefined;
                            target_field_type?: "text" | "integer" | undefined;
                            on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                            reference: string;
                            target: string;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            entity?: string | undefined;
                            min_items?: number | undefined;
                            max_items?: number | undefined;
                            mime_types?: string[] | undefined;
                        } | undefined;
                        type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly name: {
                                default?: any;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: (string | RegExp) | undefined;
                                format?: string | undefined;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema", "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                            }>;
                            readonly config: ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: any;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined>);
                        }, import("jsonv-ts").Merge<{
                            readonly title: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>, import("jsonv-ts").IRecordOptions>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: {
                            name?: string | undefined;
                            config?: {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined;
                            type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        };
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: never;
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined>;
            readonly relations: {
                additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: string;
                        }>;
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                };
            } | undefined, {
                [x: string]: never;
            } | undefined>;
            readonly indices: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly entity: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                    readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                        readonly minItems: 1;
                    }> & {
                        readonly minItems: 1;
                    };
                    readonly unique: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/media";
            }> & {
                readonly default: "/api/media";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "media";
            }> & {
                readonly default: "media";
            };
            readonly storage: import("jsonv-ts").ObjectSchema<{
                readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly adapter: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: string;
                    }>;
                    readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
                }, import("jsonv-ts").Merge<{
                    readonly title: string;
                    readonly description: string | undefined;
                } & {
                    additionalProperties: false;
                }>>[];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                config?: unknown;
                type: string;
            } | undefined, never>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/flows";
            }> & {
                readonly default: "/api/flows";
            };
            readonly flows: import("jsonv-ts").RecordSchema<import("jsonv-ts").ObjectSchema<{
                readonly trigger: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        mode: "sync" | "async";
                    } | {
                        event: string;
                        mode: "sync" | "async";
                    } | {
                        path: string;
                        mode: "sync" | "async";
                        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                        response_type: "html" | "json" | "text";
                    } | undefined;
                    type: "manual" | "event" | "http";
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: "manual" | "event" | "http";
                        }>;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            mode: "sync" | "async";
                        } | undefined, {
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly event: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly method: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                                readonly response_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
                readonly tasks: {
                    additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "log" | "fetch" | "render" | "subflow";
                            }>;
                            readonly params: import("jsonv-ts").ObjectSchema<{
                                readonly url: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^(http|https)://";
                                }> & {
                                    readonly pattern: "^(http|https)://";
                                };
                                readonly method: {
                                    readonly default: "GET";
                                    readonly enum: string[];
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly headers: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    contains?: import("jsonv-ts").Schema | undefined;
                                    minContains?: number | undefined;
                                    maxContains?: number | undefined;
                                    prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                    uniqueItems?: boolean | undefined;
                                    maxItems?: number | undefined;
                                    minItems?: number | undefined;
                                    readonly items?: import("jsonv-ts").ObjectSchema<{
                                        readonly key: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                        readonly value: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>> | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    key: string;
                                    value: string;
                                }[] | undefined, {
                                    key: string;
                                    value: string;
                                }[] | undefined>;
                                readonly body: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly normal: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly delay: import("jsonv-ts").Schema<{
                                    readonly default: 10;
                                }, number, number> & {
                                    readonly default: 10;
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly render: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly flow: import("jsonv-ts").Schema<import("jsonv-ts").IAnyOptions, any, any> & import("jsonv-ts").IAnyOptions;
                                readonly input: {
                                    [x: string]: any;
                                    [x: number]: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                readonly loop: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        }, import("jsonv-ts").Merge<{
                            readonly title: string;
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    };
                } | undefined, {
                    [x: string]: never;
                } | undefined>;
                readonly connections: {
                    additionalProperties: import("jsonv-ts").ObjectSchema<{
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: import("jsonv-ts").ObjectSchema<{
                            readonly condition: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined, {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined>;
                            readonly max_retries: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined>;
                readonly start_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly responding_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>, {
                readonly default: {};
            }>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>>;
        media: import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/auth";
            }> & {
                readonly default: "/api/auth";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "users";
            }> & {
                readonly default: "users";
            };
            readonly allow_register: {
                readonly default: true;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
            readonly jwt: import("jsonv-ts").ObjectSchema<{
                readonly secret: import("./core/utils").SecretSchema<{
                    default: string;
                }> & {
                    default: string;
                };
                readonly alg: {
                    readonly default: "HS256";
                    readonly enum: ["HS256", "HS384", "HS512"];
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "HS256" | "HS384" | "HS512" | undefined, "HS256" | "HS384" | "HS512" | undefined>;
                readonly expires: {
                    default?: any;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                    multipleOf?: number | undefined;
                    maximum?: number | undefined;
                    exclusiveMaximum?: number | undefined;
                    minimum?: number | undefined;
                    exclusiveMinimum?: number | undefined;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly issuer: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["id", "email", "role"];
                }> & {
                    readonly default: readonly ["id", "email", "role"];
                };
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly cookie: import("jsonv-ts").ObjectSchema<{
                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly sameSite: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "strict" | "lax" | "none" | undefined, "strict" | "lax" | "none" | undefined>;
                readonly secure: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly httpOnly: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly expires: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly partitioned: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly renew: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly pathSuccess: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly pathLoggedOut: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
            readonly strategies: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                enabled?: boolean | undefined;
                type: "password" | "oauth" | "custom_oauth";
                config: {
                    rounds?: number | undefined;
                    hashing: "plain" | "sha256" | "bcrypt";
                } | {
                    [x: string]: unknown;
                    name: "google" | "github";
                    type: "oidc" | "oauth2";
                    client: {
                        client_id: string;
                        client_secret: string;
                    };
                } | {
                    name: string;
                    type: "oidc" | "oauth2";
                    client: {
                        [x: string]: unknown;
                        client_id: string;
                        client_secret: string;
                        token_endpoint_auth_method: "client_secret_basic";
                    };
                    as: {
                        code_challenge_methods_supported?: "S256" | undefined;
                        scopes_supported?: string[] | undefined;
                        scope_separator?: string | undefined;
                        authorization_endpoint?: string | undefined;
                        token_endpoint?: string | undefined;
                        userinfo_endpoint?: string | undefined;
                        issuer: string;
                    };
                };
            }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: true;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "password" | "oauth" | "custom_oauth", "password" | "oauth" | "custom_oauth"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: "password" | "oauth" | "custom_oauth";
                    }>;
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly hashing: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        }> & {
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        };
                        readonly rounds: {
                            readonly maximum: 10;
                            readonly minimum: 1;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>> | (import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").StringSchema<{
                            readonly enum: ("google" | "github")[];
                        }> & {
                            readonly enum: ("google" | "github")[];
                        };
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        };
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, {
                        readonly title: "OAuth";
                    }> & {
                        readonly title: "OAuth";
                    }) | import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        };
                        readonly name: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly token_endpoint_auth_method: import("jsonv-ts").StringSchema<{
                                readonly enum: readonly ["client_secret_basic"];
                            }> & {
                                readonly enum: readonly ["client_secret_basic"];
                            };
                        }, import("jsonv-ts").IObjectOptions> & import("jsonv-ts").IObjectOptions;
                        readonly as: import("jsonv-ts").ObjectSchema<{
                            readonly issuer: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly code_challenge_methods_supported: {
                                readonly enum: ["S256"];
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "S256" | undefined, "S256" | undefined>;
                            readonly scopes_supported: {
                                default?: any;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                contains?: import("jsonv-ts").Schema | undefined;
                                minContains?: number | undefined;
                                maxContains?: number | undefined;
                                prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                uniqueItems?: boolean | undefined;
                                maxItems?: number | undefined;
                                minItems?: number | undefined;
                                readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                            readonly scope_separator: {
                                readonly default: " ";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly authorization_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly token_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly userinfo_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<{
                        readonly title: "Custom OAuth";
                    } & {
                        additionalProperties: false;
                    }>>;
                }, import("jsonv-ts").Merge<{
                    readonly title: "password" | "oauth" | "custom_oauth";
                } & {
                    additionalProperties: false;
                }>>[];
            }>, {
                readonly title: "Strategies";
                readonly default: {
                    readonly password: {
                        readonly type: "password";
                        readonly enabled: true;
                        readonly config: {
                            readonly hashing: "sha256";
                        };
                    };
                };
            }>;
            readonly guard: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                minProperties?: number | undefined;
                maxProperties?: number | undefined;
                propertyNames?: import("jsonv-ts").Schema | undefined;
                strict: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
                properties: {
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                };
                required: string[] | undefined;
                partial: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").IObjectOptions>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined>;
            readonly roles: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly permissions: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                        contains?: import("jsonv-ts").Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: import("jsonv-ts").Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                    readonly is_default: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly implicit_allow: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly title: "Authentication";
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly cors: import("jsonv-ts").ObjectSchema<{
                readonly origin: import("jsonv-ts").StringSchema<{
                    readonly default: "*";
                }> & {
                    readonly default: "*";
                };
                readonly allow_methods: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }> & {
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }, {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                }> & {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                };
                readonly allow_headers: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                }> & {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                };
                readonly allow_credentials: import("jsonv-ts").Schema<{
                    readonly default: true;
                }, boolean, boolean> & {
                    readonly default: true;
                };
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: {
                readonly default: "/api/data";
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            readonly default_primary_format: {
                readonly default: "integer";
                readonly enum: readonly ["integer", "uuid"];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
            readonly entities: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly name: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                    readonly type: import("jsonv-ts").StringSchema<{
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    }> & {
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    };
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly name_singular: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_dir: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "asc" | "desc" | undefined, "asc" | "desc" | undefined>;
                        readonly primary_format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                    readonly fields: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        name?: string | undefined;
                        config?: {
                            description?: string | undefined;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            html_config?: {
                                [x: string]: unknown;
                                element?: string | undefined;
                                props?: {
                                    [x: string]: string | number;
                                } | undefined;
                            } | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            format?: "integer" | "uuid" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                            required?: boolean | undefined;
                            default_value?: number | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: boolean | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            type?: "date" | "week" | "datetime" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            timezone?: string | undefined;
                            min_date?: string | undefined;
                            max_date?: string | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            options?: {
                                [x: string]: unknown;
                                values: string[];
                                type: "strings";
                            } | {
                                [x: string]: unknown;
                                values: {
                                    [x: string]: unknown;
                                    value: string;
                                    label: string;
                                }[];
                                type: "objects";
                            } | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            schema?: any;
                            ui_schema?: any;
                            default_from_schema?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            target_field?: string | undefined;
                            target_field_type?: "text" | "integer" | undefined;
                            on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                            reference: string;
                            target: string;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            entity?: string | undefined;
                            min_items?: number | undefined;
                            max_items?: number | undefined;
                            mime_types?: string[] | undefined;
                        } | undefined;
                        type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly name: {
                                default?: any;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: (string | RegExp) | undefined;
                                format?: string | undefined;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema", "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                            }>;
                            readonly config: ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: any;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined>);
                        }, import("jsonv-ts").Merge<{
                            readonly title: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>, import("jsonv-ts").IRecordOptions>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: {
                            name?: string | undefined;
                            config?: {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined;
                            type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        };
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: never;
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined>;
            readonly relations: {
                additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: string;
                        }>;
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                };
            } | undefined, {
                [x: string]: never;
            } | undefined>;
            readonly indices: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly entity: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                    readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                        readonly minItems: 1;
                    }> & {
                        readonly minItems: 1;
                    };
                    readonly unique: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/media";
            }> & {
                readonly default: "/api/media";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "media";
            }> & {
                readonly default: "media";
            };
            readonly storage: import("jsonv-ts").ObjectSchema<{
                readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly adapter: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: string;
                    }>;
                    readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
                }, import("jsonv-ts").Merge<{
                    readonly title: string;
                    readonly description: string | undefined;
                } & {
                    additionalProperties: false;
                }>>[];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                config?: unknown;
                type: string;
            } | undefined, never>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/flows";
            }> & {
                readonly default: "/api/flows";
            };
            readonly flows: import("jsonv-ts").RecordSchema<import("jsonv-ts").ObjectSchema<{
                readonly trigger: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        mode: "sync" | "async";
                    } | {
                        event: string;
                        mode: "sync" | "async";
                    } | {
                        path: string;
                        mode: "sync" | "async";
                        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                        response_type: "html" | "json" | "text";
                    } | undefined;
                    type: "manual" | "event" | "http";
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: "manual" | "event" | "http";
                        }>;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            mode: "sync" | "async";
                        } | undefined, {
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly event: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly method: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                                readonly response_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
                readonly tasks: {
                    additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "log" | "fetch" | "render" | "subflow";
                            }>;
                            readonly params: import("jsonv-ts").ObjectSchema<{
                                readonly url: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^(http|https)://";
                                }> & {
                                    readonly pattern: "^(http|https)://";
                                };
                                readonly method: {
                                    readonly default: "GET";
                                    readonly enum: string[];
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly headers: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    contains?: import("jsonv-ts").Schema | undefined;
                                    minContains?: number | undefined;
                                    maxContains?: number | undefined;
                                    prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                    uniqueItems?: boolean | undefined;
                                    maxItems?: number | undefined;
                                    minItems?: number | undefined;
                                    readonly items?: import("jsonv-ts").ObjectSchema<{
                                        readonly key: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                        readonly value: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>> | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    key: string;
                                    value: string;
                                }[] | undefined, {
                                    key: string;
                                    value: string;
                                }[] | undefined>;
                                readonly body: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly normal: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly delay: import("jsonv-ts").Schema<{
                                    readonly default: 10;
                                }, number, number> & {
                                    readonly default: 10;
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly render: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly flow: import("jsonv-ts").Schema<import("jsonv-ts").IAnyOptions, any, any> & import("jsonv-ts").IAnyOptions;
                                readonly input: {
                                    [x: string]: any;
                                    [x: number]: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                readonly loop: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        }, import("jsonv-ts").Merge<{
                            readonly title: string;
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    };
                } | undefined, {
                    [x: string]: never;
                } | undefined>;
                readonly connections: {
                    additionalProperties: import("jsonv-ts").ObjectSchema<{
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: import("jsonv-ts").ObjectSchema<{
                            readonly condition: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined, {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined>;
                            readonly max_retries: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined>;
                readonly start_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly responding_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>, {
                readonly default: {};
            }>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>>;
        flows: import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/auth";
            }> & {
                readonly default: "/api/auth";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "users";
            }> & {
                readonly default: "users";
            };
            readonly allow_register: {
                readonly default: true;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
            readonly jwt: import("jsonv-ts").ObjectSchema<{
                readonly secret: import("./core/utils").SecretSchema<{
                    default: string;
                }> & {
                    default: string;
                };
                readonly alg: {
                    readonly default: "HS256";
                    readonly enum: ["HS256", "HS384", "HS512"];
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "HS256" | "HS384" | "HS512" | undefined, "HS256" | "HS384" | "HS512" | undefined>;
                readonly expires: {
                    default?: any;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                    multipleOf?: number | undefined;
                    maximum?: number | undefined;
                    exclusiveMaximum?: number | undefined;
                    minimum?: number | undefined;
                    exclusiveMinimum?: number | undefined;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly issuer: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["id", "email", "role"];
                }> & {
                    readonly default: readonly ["id", "email", "role"];
                };
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly cookie: import("jsonv-ts").ObjectSchema<{
                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly sameSite: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "strict" | "lax" | "none" | undefined, "strict" | "lax" | "none" | undefined>;
                readonly secure: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly httpOnly: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly expires: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                readonly partitioned: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly renew: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                readonly pathSuccess: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly pathLoggedOut: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
            readonly strategies: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                enabled?: boolean | undefined;
                type: "password" | "oauth" | "custom_oauth";
                config: {
                    rounds?: number | undefined;
                    hashing: "plain" | "sha256" | "bcrypt";
                } | {
                    [x: string]: unknown;
                    name: "google" | "github";
                    type: "oidc" | "oauth2";
                    client: {
                        client_id: string;
                        client_secret: string;
                    };
                } | {
                    name: string;
                    type: "oidc" | "oauth2";
                    client: {
                        [x: string]: unknown;
                        client_id: string;
                        client_secret: string;
                        token_endpoint_auth_method: "client_secret_basic";
                    };
                    as: {
                        code_challenge_methods_supported?: "S256" | undefined;
                        scopes_supported?: string[] | undefined;
                        scope_separator?: string | undefined;
                        authorization_endpoint?: string | undefined;
                        token_endpoint?: string | undefined;
                        userinfo_endpoint?: string | undefined;
                        issuer: string;
                    };
                };
            }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: true;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "password" | "oauth" | "custom_oauth", "password" | "oauth" | "custom_oauth"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: "password" | "oauth" | "custom_oauth";
                    }>;
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly hashing: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        }> & {
                            readonly enum: readonly ["plain", "sha256", "bcrypt"];
                            readonly default: "sha256";
                        };
                        readonly rounds: {
                            readonly maximum: 10;
                            readonly minimum: 1;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>> | (import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").StringSchema<{
                            readonly enum: ("google" | "github")[];
                        }> & {
                            readonly enum: ("google" | "github")[];
                        };
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oauth2";
                        };
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, {
                        readonly title: "OAuth";
                    }> & {
                        readonly title: "OAuth";
                    }) | import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").StringSchema<{
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        }> & {
                            readonly enum: readonly ["oidc", "oauth2"];
                            readonly default: "oidc";
                        };
                        readonly name: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly client: import("jsonv-ts").ObjectSchema<{
                            readonly client_id: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly client_secret: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly token_endpoint_auth_method: import("jsonv-ts").StringSchema<{
                                readonly enum: readonly ["client_secret_basic"];
                            }> & {
                                readonly enum: readonly ["client_secret_basic"];
                            };
                        }, import("jsonv-ts").IObjectOptions> & import("jsonv-ts").IObjectOptions;
                        readonly as: import("jsonv-ts").ObjectSchema<{
                            readonly issuer: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            readonly code_challenge_methods_supported: {
                                readonly enum: ["S256"];
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "S256" | undefined, "S256" | undefined>;
                            readonly scopes_supported: {
                                default?: any;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                contains?: import("jsonv-ts").Schema | undefined;
                                minContains?: number | undefined;
                                maxContains?: number | undefined;
                                prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                uniqueItems?: boolean | undefined;
                                maxItems?: number | undefined;
                                minItems?: number | undefined;
                                readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                            readonly scope_separator: {
                                readonly default: " ";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly authorization_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly token_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly userinfo_endpoint: {
                                readonly pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$";
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<{
                        readonly title: "Custom OAuth";
                    } & {
                        additionalProperties: false;
                    }>>;
                }, import("jsonv-ts").Merge<{
                    readonly title: "password" | "oauth" | "custom_oauth";
                } & {
                    additionalProperties: false;
                }>>[];
            }>, {
                readonly title: "Strategies";
                readonly default: {
                    readonly password: {
                        readonly type: "password";
                        readonly enabled: true;
                        readonly config: {
                            readonly hashing: "sha256";
                        };
                    };
                };
            }>;
            readonly guard: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                minProperties?: number | undefined;
                maxProperties?: number | undefined;
                propertyNames?: import("jsonv-ts").Schema | undefined;
                strict: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
                properties: {
                    readonly enabled: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                };
                required: string[] | undefined;
                partial: () => import("jsonv-ts").ObjectSchema<{
                    readonly enabled: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").IObjectOptions>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined, {
                [x: string]: unknown;
                enabled?: boolean | undefined;
            } | undefined>;
            readonly roles: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly permissions: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                        contains?: import("jsonv-ts").Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: import("jsonv-ts").Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: (import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions) | undefined;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                    readonly is_default: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                    readonly implicit_allow: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined, {
                [x: string]: {
                    permissions?: string[] | undefined;
                    is_default?: boolean | undefined;
                    implicit_allow?: boolean | undefined;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<{
            readonly title: "Authentication";
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly cors: import("jsonv-ts").ObjectSchema<{
                readonly origin: import("jsonv-ts").StringSchema<{
                    readonly default: "*";
                }> & {
                    readonly default: "*";
                };
                readonly allow_methods: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }> & {
                    readonly enum: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                }, {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                }> & {
                    readonly default: readonly ["GET", "POST", "PATCH", "PUT", "DELETE"];
                    readonly uniqueItems: true;
                };
                readonly allow_headers: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                }> & {
                    readonly default: readonly ["Content-Type", "Content-Length", "Authorization", "Accept"];
                };
                readonly allow_credentials: import("jsonv-ts").Schema<{
                    readonly default: true;
                }, boolean, boolean> & {
                    readonly default: true;
                };
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: {
                readonly default: "/api/data";
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            readonly default_primary_format: {
                readonly default: "integer";
                readonly enum: readonly ["integer", "uuid"];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
            readonly entities: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly name: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                    readonly type: import("jsonv-ts").StringSchema<{
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    }> & {
                        readonly enum: readonly ["regular", "system", "generated"];
                        readonly default: "regular";
                    };
                    readonly config: import("jsonv-ts").ObjectSchema<{
                        readonly name: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly name_singular: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                        readonly sort_dir: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "asc" | "desc" | undefined, "asc" | "desc" | undefined>;
                        readonly primary_format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                    readonly fields: import("jsonv-ts").RecordSchema<import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        name?: string | undefined;
                        config?: {
                            description?: string | undefined;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            html_config?: {
                                [x: string]: unknown;
                                element?: string | undefined;
                                props?: {
                                    [x: string]: string | number;
                                } | undefined;
                            } | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            format?: "integer" | "uuid" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                            required?: boolean | undefined;
                            default_value?: number | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: boolean | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            type?: "date" | "week" | "datetime" | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            timezone?: string | undefined;
                            min_date?: string | undefined;
                            max_date?: string | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: string | undefined;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            options?: {
                                [x: string]: unknown;
                                values: string[];
                                type: "strings";
                            } | {
                                [x: string]: unknown;
                                values: {
                                    [x: string]: unknown;
                                    value: string;
                                    label: string;
                                }[];
                                type: "objects";
                            } | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            schema?: any;
                            ui_schema?: any;
                            default_from_schema?: boolean | undefined;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            target_field?: string | undefined;
                            target_field_type?: "text" | "integer" | undefined;
                            on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                            reference: string;
                            target: string;
                        } | {
                            description?: string | undefined;
                            required?: boolean | undefined;
                            default_value?: any;
                            label?: string | undefined;
                            fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                            hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                            virtual?: boolean | undefined;
                            entity?: string | undefined;
                            min_items?: number | undefined;
                            max_items?: number | undefined;
                            mime_types?: string[] | undefined;
                        } | undefined;
                        type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly name: {
                                default?: any;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: (string | RegExp) | undefined;
                                format?: string | undefined;
                                enum?: (readonly any[] | any[]) | undefined;
                                const?: any;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema", "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                            }>;
                            readonly config: ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly minLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maxLength: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly pattern: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly html_config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined, {
                                        [x: string]: unknown;
                                        element?: string | undefined;
                                        props?: {
                                            [x: string]: string | number;
                                        } | undefined;
                                    } | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly format: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "integer" | "uuid" | undefined, "integer" | "uuid" | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly minimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly maximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMinimum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly exclusiveMaximum: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly multipleOf: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "date" | "week" | "datetime" | undefined, "date" | "week" | "datetime" | undefined>;
                                    readonly timezone: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly max_date: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly options: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                        [x: string]: unknown;
                                        values: string[];
                                        type: "strings";
                                    } | {
                                        [x: string]: unknown;
                                        values: {
                                            [x: string]: unknown;
                                            value: string;
                                            label: string;
                                        }[];
                                        type: "objects";
                                    } | undefined, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: any;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly ui_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly default_from_schema: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    readonly target_field: {
                                        readonly default: "id";
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: {
                                        readonly default: "integer";
                                        readonly enum: ["text", "integer"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: {
                                        readonly default: "set null";
                                        readonly enum: readonly ["cascade", "set null", "set default", "restrict", "no action"];
                                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly reference: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly target_field_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "text" | "integer" | undefined, "text" | "integer" | undefined>;
                                    readonly on_delete: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined, "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | undefined>) | ({
                                strict: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }> & {
                                    additionalProperties: false;
                                }>>;
                                properties: {
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                };
                                required: string[] | undefined;
                                partial: () => import("jsonv-ts").ObjectSchema<{
                                    readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly description: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly fillable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("create" | "read" | "update" | "delete")[] | undefined, boolean | ("create" | "read" | "update" | "delete")[] | undefined>;
                                    readonly hidden: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined, boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined>;
                                    readonly virtual: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                    readonly default_value: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                    readonly entity: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    readonly min_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly max_items: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                    readonly mime_types: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string[] | undefined, string[] | undefined>;
                                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                    additionalProperties: false;
                                }>>;
                            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined, {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined>);
                        }, import("jsonv-ts").Merge<{
                            readonly title: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>, import("jsonv-ts").IRecordOptions>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: {
                            name?: string | undefined;
                            config?: {
                                description?: string | undefined;
                                maxLength?: number | undefined;
                                minLength?: number | undefined;
                                pattern?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                html_config?: {
                                    [x: string]: unknown;
                                    element?: string | undefined;
                                    props?: {
                                        [x: string]: string | number;
                                    } | undefined;
                                } | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                format?: "integer" | "uuid" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                multipleOf?: number | undefined;
                                maximum?: number | undefined;
                                exclusiveMaximum?: number | undefined;
                                minimum?: number | undefined;
                                exclusiveMinimum?: number | undefined;
                                required?: boolean | undefined;
                                default_value?: number | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: boolean | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                type?: "date" | "week" | "datetime" | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                timezone?: string | undefined;
                                min_date?: string | undefined;
                                max_date?: string | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: string | undefined;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                options?: {
                                    [x: string]: unknown;
                                    values: string[];
                                    type: "strings";
                                } | {
                                    [x: string]: unknown;
                                    values: {
                                        [x: string]: unknown;
                                        value: string;
                                        label: string;
                                    }[];
                                    type: "objects";
                                } | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                schema?: any;
                                ui_schema?: any;
                                default_from_schema?: boolean | undefined;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                target_field?: string | undefined;
                                target_field_type?: "text" | "integer" | undefined;
                                on_delete?: "cascade" | "set null" | "set default" | "restrict" | "no action" | undefined;
                                reference: string;
                                target: string;
                            } | {
                                description?: string | undefined;
                                required?: boolean | undefined;
                                default_value?: any;
                                label?: string | undefined;
                                fillable?: boolean | ("create" | "read" | "update" | "delete")[] | undefined;
                                hidden?: boolean | ("table" | "form" | "create" | "read" | "update" | "delete" | "submit")[] | undefined;
                                virtual?: boolean | undefined;
                                entity?: string | undefined;
                                min_items?: number | undefined;
                                max_items?: number | undefined;
                                mime_types?: string[] | undefined;
                            } | undefined;
                            type: "number" | "boolean" | "json" | "text" | "enum" | "date" | "media" | "relation" | "primary" | "jsonschema";
                        };
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined, {
                [x: string]: {
                    name?: string | undefined;
                    type: "regular" | "system" | "generated";
                    fields: {
                        [x: string]: never;
                    };
                    config: {
                        description?: string | undefined;
                        name?: string | undefined;
                        name_singular?: string | undefined;
                        sort_field?: string | undefined;
                        sort_dir?: "asc" | "desc" | undefined;
                        primary_format?: "integer" | "uuid" | undefined;
                    };
                };
            } | undefined>;
            readonly relations: {
                additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: string;
                        }>;
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: {
                                    readonly default: number;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    patternProperties?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    additionalProperties?: (import("jsonv-ts").Schema | false) | undefined;
                                    minProperties?: number | undefined;
                                    maxProperties?: number | undefined;
                                    propertyNames?: import("jsonv-ts").Schema | undefined;
                                    strict: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>>;
                                    properties: {
                                        readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    };
                                    required: string[] | undefined;
                                    partial: () => import("jsonv-ts").ObjectSchema<{
                                        readonly label: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                    }, import("jsonv-ts").IObjectOptions>;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly sourceCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly with_limit: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                                readonly fieldConfig: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined, {
                                    [x: string]: unknown;
                                    label: string;
                                } | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            sourceCardinality?: number | undefined;
                            with_limit?: number | undefined;
                            fieldConfig?: {
                                [x: string]: unknown;
                                label: string;
                            } | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly connectionTable: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly connectionTableMappedName: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            connectionTable?: string | undefined;
                            connectionTableMappedName?: string | undefined;
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mappedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mappedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly inversedBy: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly required: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                                readonly targetCardinality: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined, {
                            required?: boolean | undefined;
                            mappedBy?: string | undefined;
                            inversedBy?: string | undefined;
                            targetCardinality?: number | undefined;
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    config?: {
                        required?: boolean | undefined;
                        sourceCardinality?: number | undefined;
                        with_limit?: number | undefined;
                        fieldConfig?: {
                            [x: string]: unknown;
                            label: string;
                        } | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        connectionTable?: string | undefined;
                        connectionTableMappedName?: string | undefined;
                    } | {
                        required?: boolean | undefined;
                        mappedBy?: string | undefined;
                        inversedBy?: string | undefined;
                        targetCardinality?: number | undefined;
                    } | undefined;
                    type: string;
                    target: string;
                    source: string;
                };
            } | undefined, {
                [x: string]: never;
            } | undefined>;
            readonly indices: {
                additionalProperties: import("jsonv-ts").ObjectSchema<{
                    readonly entity: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                    readonly fields: import("jsonv-ts").ArraySchema<import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions, {
                        readonly minItems: 1;
                    }> & {
                        readonly minItems: 1;
                    };
                    readonly unique: {
                        readonly default: false;
                    } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined, {
                [x: string]: {
                    unique?: boolean | undefined;
                    fields: string[];
                    entity: string;
                };
            } | undefined>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly enabled: import("jsonv-ts").Schema<{
                readonly default: false;
            }, boolean, boolean> & {
                readonly default: false;
            };
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/media";
            }> & {
                readonly default: "/api/media";
            };
            readonly entity_name: import("jsonv-ts").StringSchema<{
                readonly default: "media";
            }> & {
                readonly default: "media";
            };
            readonly storage: import("jsonv-ts").ObjectSchema<{
                readonly body_max_size: {} & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
            }, import("jsonv-ts").Merge<{
                readonly default: {};
            } & {
                additionalProperties: false;
            }>>;
            readonly adapter: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                anyOf: import("jsonv-ts").ObjectSchema<{
                    readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, string, string> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                        const: string;
                    }>;
                    readonly config: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, unknown, unknown>;
                }, import("jsonv-ts").Merge<{
                    readonly title: string;
                    readonly description: string | undefined;
                } & {
                    additionalProperties: false;
                }>>[];
            } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                config?: unknown;
                type: string;
            } | undefined, never>;
        }, import("jsonv-ts").Merge<{
            readonly default: {};
        } & {
            additionalProperties: false;
        }>> | import("jsonv-ts").ObjectSchema<{
            readonly basepath: import("jsonv-ts").StringSchema<{
                readonly default: "/api/flows";
            }> & {
                readonly default: "/api/flows";
            };
            readonly flows: import("jsonv-ts").RecordSchema<import("jsonv-ts").ObjectSchema<{
                readonly trigger: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                    config?: {
                        mode: "sync" | "async";
                    } | {
                        event: string;
                        mode: "sync" | "async";
                    } | {
                        path: string;
                        mode: "sync" | "async";
                        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                        response_type: "html" | "json" | "text";
                    } | undefined;
                    type: "manual" | "event" | "http";
                }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                    anyOf: import("jsonv-ts").ObjectSchema<{
                        readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                            const: "manual" | "event" | "http";
                        }>;
                        readonly config: ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            mode: "sync" | "async";
                        } | undefined, {
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly event: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly event: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined, {
                            event: string;
                            mode: "sync" | "async";
                        } | undefined>) | ({
                            strict: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }> & {
                                additionalProperties: false;
                            }>>;
                            properties: {
                                readonly mode: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                }> & {
                                    readonly enum: readonly ["sync", "async"];
                                    readonly default: "async";
                                };
                                readonly path: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^/.*$";
                                }> & {
                                    readonly pattern: "^/.*$";
                                };
                                readonly method: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                }> & {
                                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                                    readonly default: "GET";
                                };
                                readonly response_type: import("jsonv-ts").StringSchema<{
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                }> & {
                                    readonly enum: readonly ["json", "text", "html"];
                                    readonly default: "json";
                                };
                            };
                            required: string[] | undefined;
                            partial: () => import("jsonv-ts").ObjectSchema<{
                                readonly mode: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                                readonly path: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly method: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                                readonly response_type: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined, {
                            path: string;
                            mode: "sync" | "async";
                            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                            response_type: "html" | "json" | "text";
                        } | undefined>);
                    }, import("jsonv-ts").Merge<{
                        readonly title: string;
                    } & {
                        additionalProperties: false;
                    }>>[];
                }>;
                readonly tasks: {
                    additionalProperties: import("jsonv-ts").Schema<import("jsonv-ts").IUnionOptions, {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    }, never> & import("jsonv-ts").Merge<import("jsonv-ts").IUnionOptions & {
                        anyOf: import("jsonv-ts").ObjectSchema<{
                            readonly type: import("jsonv-ts").Schema<import("jsonv-ts").ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & import("jsonv-ts").Merge<import("jsonv-ts").ILiteralOptions & {
                                const: "log" | "fetch" | "render" | "subflow";
                            }>;
                            readonly params: import("jsonv-ts").ObjectSchema<{
                                readonly url: import("jsonv-ts").StringSchema<{
                                    readonly pattern: "^(http|https)://";
                                }> & {
                                    readonly pattern: "^(http|https)://";
                                };
                                readonly method: {
                                    readonly default: "GET";
                                    readonly enum: string[];
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly headers: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    $defs?: Record<string, import("jsonv-ts").Schema> | undefined;
                                    contains?: import("jsonv-ts").Schema | undefined;
                                    minContains?: number | undefined;
                                    maxContains?: number | undefined;
                                    prefixItems?: import("jsonv-ts").Schema[] | undefined;
                                    uniqueItems?: boolean | undefined;
                                    maxItems?: number | undefined;
                                    minItems?: number | undefined;
                                    readonly items?: import("jsonv-ts").ObjectSchema<{
                                        readonly key: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                        readonly value: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                        additionalProperties: false;
                                    }>> | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                    key: string;
                                    value: string;
                                }[] | undefined, {
                                    key: string;
                                    value: string;
                                }[] | undefined>;
                                readonly body: {
                                    default?: any;
                                    maxLength?: number | undefined;
                                    minLength?: number | undefined;
                                    pattern?: (string | RegExp) | undefined;
                                    format?: string | undefined;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                                readonly normal: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                    multipleOf?: number | undefined;
                                    maximum?: number | undefined;
                                    exclusiveMaximum?: number | undefined;
                                    minimum?: number | undefined;
                                    exclusiveMinimum?: number | undefined;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly delay: import("jsonv-ts").Schema<{
                                    readonly default: 10;
                                }, number, number> & {
                                    readonly default: 10;
                                };
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly render: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>> | import("jsonv-ts").ObjectSchema<{
                                readonly flow: import("jsonv-ts").Schema<import("jsonv-ts").IAnyOptions, any, any> & import("jsonv-ts").IAnyOptions;
                                readonly input: {
                                    [x: string]: any;
                                    [x: number]: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, any, any>;
                                readonly loop: {
                                    default?: any;
                                    enum?: (readonly any[] | any[]) | undefined;
                                    const?: any;
                                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
                            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                                additionalProperties: false;
                            }>>;
                        }, import("jsonv-ts").Merge<{
                            readonly title: string;
                        } & {
                            additionalProperties: false;
                        }>>[];
                    }>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        type: "log" | "fetch" | "render" | "subflow";
                        params: {
                            method?: string | undefined;
                            headers?: {
                                key: string;
                                value: string;
                            }[] | undefined;
                            body?: string | undefined;
                            normal?: number | undefined;
                            url: string;
                        } | {
                            delay: number;
                        } | {
                            render: string;
                        } | {
                            flow?: any;
                            input?: any;
                            loop?: boolean | undefined;
                        };
                    };
                } | undefined, {
                    [x: string]: never;
                } | undefined>;
                readonly connections: {
                    additionalProperties: import("jsonv-ts").ObjectSchema<{
                        readonly source: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly target: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                        readonly config: import("jsonv-ts").ObjectSchema<{
                            readonly condition: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined, {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined>;
                            readonly max_retries: import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, number | undefined, number | undefined>;
                        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                            additionalProperties: false;
                        }>>;
                    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "success";
                            } | {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined, {
                    [x: string]: {
                        config: {
                            condition?: {
                                type: "error";
                            } | {
                                path: string;
                                value: string;
                                type: "matches";
                            } | {
                                type: "success";
                            } | undefined;
                            max_retries?: number | undefined;
                        };
                        target: string;
                        source: string;
                    };
                } | undefined>;
                readonly start_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
                readonly responding_task: {
                    default?: any;
                    maxLength?: number | undefined;
                    minLength?: number | undefined;
                    pattern?: (string | RegExp) | undefined;
                    format?: string | undefined;
                    enum?: (readonly any[] | any[]) | undefined;
                    const?: any;
                } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
            }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
                additionalProperties: false;
            }>>, {
                readonly default: {};
            }>;
        }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
            additionalProperties: false;
        }>>;
        version: number;
    };
    version(): number;
    isBuilt(): boolean;
    registerAdminController(config?: AdminControllerOptions): this;
    toJSON(secrets?: boolean): {
        version: number;
    } & ModuleConfigs;
    static create(config: CreateAppConfig): App<Connection<unknown>, AppOptions>;
    createUser(p: CreateUserPayload): Promise<import(".").Users>;
    getApi(options?: LocalApiOptions): Api;
    onUpdated<Module extends keyof Modules>(module: Module, config: ModuleConfigs[Module]): Promise<void>;
    protected onFirstBoot(): Promise<void>;
    protected onServerInit(server: Hono<ServerEnv>): Promise<void>;
    protected onModulesBuilt(ctx: ModuleBuildContext): Promise<void>;
}
export declare function createApp(config?: CreateAppConfig): App<Connection<unknown>, AppOptions>;
export {};