@antelopejs/interface-dms 0.0.1

package/dist/base/data-types/default-types.d.ts

@@ -0,0 +1,456 @@
+import type { ControllerClass, RequestContext } from "@antelopejs/interface-api";
+import type { ValueProxy, ValueProxyOrValue } from "@antelopejs/interface-database";
+import { type UploadConstraints } from "@antelopejs/interface-file-storage";
+import { z } from "zod";
+import { FormComponents } from "../form-schema";
+import type { TreeNode } from "../tree";
+import { DataType } from "./core";
+export declare namespace DefaultDataTypes {
+    export type NumberTypeOptions = {
+        min?: number;
+        max?: number;
+        step?: number;
+        placeholder?: string;
+        fallback?: string;
+    };
+    export type StringTypeOptions = {
+        placeholder?: string;
+        maxLength?: number;
+        minLength?: number;
+        textarea?: boolean;
+        rows?: number;
+        fallback?: string;
+    };
+    export type DateTypeOptions = {
+        range?: boolean;
+        multiple?: boolean;
+        minDate?: string;
+        maxDate?: string;
+        fallback?: string;
+    };
+    export type BooleanTypeOptions = {
+        fallback?: string;
+    };
+    export type SelectTypeOptions = {
+        items: FormComponents.SelectOption[];
+        placeholder?: string;
+        multiple?: boolean;
+        deselectable?: boolean;
+        fallback?: string;
+    };
+    export type EmailTypeOptions = {
+        placeholder?: string;
+        fallback?: string;
+    };
+    export type ColorTypeOptions = {
+        placeholder?: string;
+        fallback?: string;
+    };
+    export type PasswordTypeOptions = {
+        placeholder?: string;
+        minLength?: number;
+        confirmPassword?: boolean;
+        confirmPlaceholder?: string;
+        fallback?: string;
+    };
+    export type UrlTypeOptions = {
+        placeholder?: string;
+        fallback?: string;
+    };
+    export type PhoneTypeOptions = {
+        placeholder?: string;
+        requiredPrefix?: boolean;
+        fallback?: string;
+    };
+    export type TreeTypeOptions = {
+        items?: TreeNode[];
+        fetchUrl?: string;
+        placeholder?: string;
+        multiple?: boolean;
+        fallback?: string;
+    };
+    export type PermissionsTypeOptions = {
+        fetchUrl?: string;
+        fallback?: string;
+    };
+    export type RichTextTypeOptions = {
+        placeholder?: string;
+        fallback?: string;
+    };
+    export type StringTimeTypeOptions = {
+        placeholder?: string;
+        min?: number;
+        max?: number;
+        fallback?: string;
+    };
+    export class NumberType extends DataType {
+        readonly options: NumberTypeOptions;
+        constructor(options?: NumberTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputNumberOptions>;
+        getValidation(): z.ZodNumber;
+    }
+    export class StringType extends DataType {
+        readonly options: StringTypeOptions;
+        constructor(options?: StringTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputTextOptions> | import("../..").ComponentInfoSerialized<FormComponents.TextareaOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class DateType extends DataType {
+        readonly options: DateTypeOptions;
+        constructor(options?: DateTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.CalendarOptions>;
+        filter(context: RequestContext, proxy: ValueProxy<unknown>, key: string, value: string, mode: string, row: ValueProxy<Record<string, unknown>>): ValueProxyOrValue<boolean>;
+        private startOfUtcDay;
+        private nextUtcDay;
+        private sameDayFilter;
+        private dayRangeFilter;
+        filterComponents(): {
+            default: import("../..").ComponentInfoSerialized<FormComponents.CalendarOptions>;
+            is_between: import("../..").ComponentInfoSerialized<FormComponents.DatePickerRangeOptions>;
+        };
+        getValidation(): z.ZodType<Date, z.ZodTypeDef, string | Date> | z.ZodArray<z.ZodType<Date, z.ZodTypeDef, string | Date>, "many">;
+    }
+    export class BooleanType extends DataType {
+        readonly options: BooleanTypeOptions;
+        constructor(options?: BooleanTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized;
+        filterComponents(): {
+            default: import("../..").ComponentInfoSerialized<{
+                items: {
+                    value: string;
+                    label: string;
+                }[];
+            }>;
+            is: import("../..").ComponentInfoSerialized<{
+                items: {
+                    value: string;
+                    label: string;
+                }[];
+            }>;
+            is_not: import("../..").ComponentInfoSerialized<{
+                items: {
+                    value: string;
+                    label: string;
+                }[];
+            }>;
+        };
+        getValidation(): z.ZodBoolean;
+    }
+    export class SelectType extends DataType {
+        readonly options: SelectTypeOptions;
+        constructor(options?: SelectTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<SelectTypeOptions>;
+        getValidation(): z.ZodEnum<[string, ...string[]]> | z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">;
+    }
+    export class PriceType extends NumberType {
+        constructor(options?: NumberTypeOptions);
+    }
+    export class PercentageType extends NumberType {
+        constructor(options?: NumberTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputNumberOptions>;
+    }
+    export class EmailType extends DataType {
+        readonly options: EmailTypeOptions;
+        constructor(options?: EmailTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputEmailOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class ColorType extends DataType {
+        readonly options: ColorTypeOptions;
+        constructor(options?: ColorTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputColorOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class PasswordType extends DataType {
+        readonly options: PasswordTypeOptions;
+        constructor(options?: PasswordTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputPasswordOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class UrlType extends DataType {
+        readonly options: UrlTypeOptions;
+        constructor(options?: UrlTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputTextOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class PhoneType extends DataType {
+        readonly options: PhoneTypeOptions;
+        constructor(options?: PhoneTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputPhoneOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class TreeType extends DataType {
+        readonly options: TreeTypeOptions;
+        constructor(options?: TreeTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<{
+            items: TreeNode[];
+            fetchUrl: string | undefined;
+            multiple: boolean | undefined;
+            placeholder: string | undefined;
+        }>;
+        getValidation(): z.ZodString | z.ZodArray<z.ZodString, "many">;
+    }
+    export class RelationType<T extends ControllerClass> extends DataType {
+        readonly options: {
+            placeholder?: string;
+            multiple?: boolean;
+            deselectable?: boolean;
+            dataApiController: T;
+            index?: string;
+            keyMapping?: {
+                label?: keyof InstanceType<T> & string;
+                value?: keyof InstanceType<T> & string;
+                avatar?: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            };
+            fallback?: string;
+            filterOnly?: boolean;
+        };
+        constructor(options: {
+            placeholder?: string;
+            multiple?: boolean;
+            deselectable?: boolean;
+            dataApiController: T;
+            index?: string;
+            keyMapping?: {
+                label?: keyof InstanceType<T> & string;
+                value?: keyof InstanceType<T> & string;
+                avatar?: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            };
+            fallback?: string;
+            filterOnly?: boolean;
+        });
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<{
+            placeholder: string | undefined;
+            multiple: boolean | undefined;
+            deselectable: boolean | undefined;
+            searchUrl: string;
+            keyMapping: {
+                label?: keyof InstanceType<T> & string;
+                value?: keyof InstanceType<T> & string;
+                avatar?: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            } | undefined;
+            addForm: import("../..").ComponentInfoSerialized<import("..").FormPropsSerialized> | undefined;
+            addPermissionId: string | undefined;
+        }>;
+        private buildAddOptions;
+        getValidation(): z.ZodType;
+        decorateField(target: unknown, key: PropertyKey, descriptor?: PropertyDescriptor): void;
+    }
+    export class CascaderRelationType<T extends ControllerClass> extends DataType {
+        readonly options: {
+            placeholder?: string;
+            multiple?: boolean;
+            deselectable?: boolean;
+            dataApiController: T;
+            index?: string;
+            keyMapping: {
+                label: keyof InstanceType<T> & string;
+                value: keyof InstanceType<T> & string;
+                parent: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            };
+            maxDepth?: number;
+            leafOnly?: boolean;
+            fallback?: string;
+            filterOnly?: boolean;
+        };
+        constructor(options: {
+            placeholder?: string;
+            multiple?: boolean;
+            deselectable?: boolean;
+            dataApiController: T;
+            index?: string;
+            keyMapping: {
+                label: keyof InstanceType<T> & string;
+                value: keyof InstanceType<T> & string;
+                parent: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            };
+            maxDepth?: number;
+            leafOnly?: boolean;
+            fallback?: string;
+            filterOnly?: boolean;
+        });
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<{
+            placeholder: string | undefined;
+            multiple: boolean | undefined;
+            deselectable: boolean | undefined;
+            searchUrl: string;
+            keyMapping: {
+                label: keyof InstanceType<T> & string;
+                value: keyof InstanceType<T> & string;
+                parent: keyof InstanceType<T> & string;
+                disabled?: keyof InstanceType<T> & string;
+            };
+            maxDepth: number | undefined;
+            leafOnly: boolean | undefined;
+            fallback: string | undefined;
+        }>;
+        getValidation(): z.ZodType;
+        decorateField(target: unknown, key: PropertyKey, descriptor?: PropertyDescriptor): void;
+    }
+    export type Address = {
+        streetName: string;
+        houseNumber?: string;
+        boxNumber?: string;
+        addressLine2?: string;
+        postalCode: string;
+        city: string;
+        countrySubdivision?: string;
+        countryCode: string;
+    };
+    type AddressPlaceholders = Partial<Record<keyof Address, string>>;
+    export type AddressAutocomplete = {
+        enabled?: boolean;
+        url?: string;
+        lang?: string;
+        limit?: number;
+        placeholder?: string;
+    };
+    export class AddressType<T extends ControllerClass = ControllerClass> extends DataType {
+        readonly options: {
+            placeholder?: AddressPlaceholders;
+            autocomplete?: AddressAutocomplete;
+            dataApiController?: T;
+            keyMapping?: {
+                label?: keyof InstanceType<T> & string;
+                value?: keyof InstanceType<T> & string;
+            };
+            fallback?: string;
+        };
+        constructor(options?: {
+            placeholder?: AddressPlaceholders;
+            autocomplete?: AddressAutocomplete;
+            dataApiController?: T;
+            keyMapping?: {
+                label?: keyof InstanceType<T> & string;
+                value?: keyof InstanceType<T> & string;
+            };
+            fallback?: string;
+        });
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<{
+            placeholder: Partial<Record<keyof Address, string>> | undefined;
+            autocomplete: AddressAutocomplete | undefined;
+        }>;
+        getValidation(): z.ZodObject<{
+            streetName: z.ZodString;
+            houseNumber: z.ZodOptional<z.ZodString>;
+            boxNumber: z.ZodOptional<z.ZodString>;
+            addressLine2: z.ZodOptional<z.ZodString>;
+            postalCode: z.ZodString;
+            city: z.ZodString;
+            countrySubdivision: z.ZodOptional<z.ZodString>;
+            countryCode: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            streetName: string;
+            postalCode: string;
+            city: string;
+            countryCode: string;
+            houseNumber?: string | undefined;
+            boxNumber?: string | undefined;
+            addressLine2?: string | undefined;
+            countrySubdivision?: string | undefined;
+        }, {
+            streetName: string;
+            postalCode: string;
+            city: string;
+            countryCode: string;
+            houseNumber?: string | undefined;
+            boxNumber?: string | undefined;
+            addressLine2?: string | undefined;
+            countrySubdivision?: string | undefined;
+        }>;
+    }
+    export class PermissionsType extends DataType {
+        readonly options: PermissionsTypeOptions;
+        constructor(options?: PermissionsTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<{
+            fetchUrl: string | undefined;
+        }>;
+        getValidation(): z.ZodArray<z.ZodString, "many">;
+    }
+    export class RichTextType extends DataType {
+        readonly options: RichTextTypeOptions;
+        constructor(options?: RichTextTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.RichTextOptions>;
+        getValidation(): z.ZodString;
+    }
+    export class StringTimeType extends DataType {
+        readonly options: StringTimeTypeOptions;
+        constructor(options?: StringTimeTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.InputTimeOptions>;
+        getValidation(): z.ZodNumber;
+    }
+    export interface FileTypeOptions extends Record<string, unknown> {
+        multiple?: boolean;
+        constraints?: UploadConstraints;
+        path?: string;
+        storage?: string;
+        fallback?: string;
+        attachmentField?: string;
+        visibility?: "private" | "public";
+    }
+    export class FileType extends DataType {
+        readonly options: FileTypeOptions;
+        constructor(options?: FileTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.FileOptions>;
+        getValidation(): z.ZodLazy<z.ZodEffects<z.ZodString, string, string>> | z.ZodArray<z.ZodLazy<z.ZodEffects<z.ZodString, string, string>>, "many">;
+    }
+    export interface ImageValue {
+        key: string;
+        alt?: string;
+        principal?: boolean;
+    }
+    export interface ImageTypeOptions extends Record<string, unknown> {
+        multiple?: boolean;
+        max?: number;
+        constraints?: UploadConstraints;
+        path?: string;
+        storage?: string;
+        resize?: FormComponents.ImageResizeOptions;
+        attachmentField?: string;
+        visibility?: "private" | "public";
+    }
+    export class ImageType extends DataType {
+        readonly options: ImageTypeOptions;
+        constructor(options?: ImageTypeOptions);
+        protected defaultInputComponent(): import("../..").ComponentInfoSerialized<FormComponents.ImageOptions>;
+        getValidation(): z.ZodLazy<z.ZodObject<{
+            key: z.ZodEffects<z.ZodString, string, string>;
+            alt: z.ZodOptional<z.ZodString>;
+            principal: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }, {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }>> | z.ZodEffects<z.ZodArray<z.ZodLazy<z.ZodObject<{
+            key: z.ZodEffects<z.ZodString, string, string>;
+            alt: z.ZodOptional<z.ZodString>;
+            principal: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }, {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }>>, "many">, {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }[], {
+            key: string;
+            alt?: string | undefined;
+            principal?: boolean | undefined;
+        }[]>;
+    }
+    export {};
+}