bknd/dist/types/data/relations/index.d.ts

Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.

import { ManyToManyRelation, type ManyToManyRelationConfig } from "./ManyToManyRelation";
import { ManyToOneRelation, type ManyToOneRelationConfig } from "./ManyToOneRelation";
import { OneToOneRelation, type OneToOneRelationConfig } from "./OneToOneRelation";
import { PolymorphicRelation, type PolymorphicRelationConfig } from "./PolymorphicRelation";
import { type RelationType, RelationTypes } from "./relation-types";
export * from "./EntityRelation";
export * from "./EntityRelationAnchor";
export * from "./RelationHelper";
export * from "./RelationMutator";
export * from "./RelationAccessor";
import { RelationField, type RelationFieldBaseConfig, type RelationFieldConfig, relationFieldConfigSchema } from "./RelationField";
export { OneToOneRelation, type OneToOneRelationConfig, ManyToOneRelation, type ManyToOneRelationConfig, ManyToManyRelation, type ManyToManyRelationConfig, PolymorphicRelation, type PolymorphicRelationConfig, RelationTypes, type RelationType, RelationField, relationFieldConfigSchema, type RelationFieldBaseConfig, type RelationFieldConfig, };
export declare const RelationClassMap: {
    readonly "1:1": {
        readonly schema: 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;
                properties: {
                    readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                };
                required: string[] | 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;
                }>>;
                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").IObjectOptions & {
            additionalProperties: false;
        }>>;
        readonly cls: typeof OneToOneRelation;
    };
    readonly "n:1": {
        readonly schema: 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;
                properties: {
                    readonly label: import("jsonv-ts").StringSchema<import("jsonv-ts").IStringOptions> & import("jsonv-ts").IStringOptions;
                };
                required: string[] | 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;
                }>>;
                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").IObjectOptions & {
            additionalProperties: false;
        }>>;
        readonly cls: typeof ManyToOneRelation;
    };
    readonly "m:n": {
        readonly schema: 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").IObjectOptions & {
            additionalProperties: false;
        }>>;
        readonly cls: typeof ManyToManyRelation;
    };
    readonly poly: {
        readonly schema: 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").IObjectOptions & {
            additionalProperties: false;
        }>>;
        readonly cls: typeof PolymorphicRelation;
    };
};
export declare const RelationFieldClassMap: {
    readonly relation: {
        readonly schema: 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" | "create" | "read" | "update" | "delete" | "form" | "submit")[] | undefined, boolean | ("table" | "create" | "read" | "update" | "delete" | "form" | "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").IObjectOptions & {
            additionalProperties: false;
        }>>;
        readonly field: typeof RelationField;
    };
};