@xlabs-store/core 0.0.1

package/dist/types/components/x-form-builder/services/apis/api-client.d.ts

@@ -0,0 +1,63 @@
+import { ApiConfiguration } from '../../types';
+export declare class ApiClient {
+    private config;
+    private abortController;
+    constructor(config: ApiConfiguration);
+    /**
+     * Execute API request với retry logic
+     */
+    execute<T = any>(): Promise<T>;
+    /**
+     * Thực hiện request
+     */
+    private makeRequest;
+    /**
+     * Build URL với query parameters
+     */
+    private buildUrl;
+    /**
+     * Build request options
+     */
+    private buildRequestOptions;
+    /**
+     * Build headers
+     */
+    private buildHeaders;
+    /**
+     * Thêm authentication headers
+     */
+    private addAuthenticationHeaders;
+    /**
+     * Get Content-Type based on bodyType
+     */
+    private getContentType;
+    /**
+     * Build request body
+     */
+    private buildBody;
+    /**
+     * Build FormData
+     */
+    private buildFormData;
+    /**
+     * Build URL encoded body
+     */
+    private buildUrlEncoded;
+    /**
+     * Parse response based on content type
+     */
+    private parseResponse;
+    /**
+     * Delay helper for retry
+     */
+    private delay;
+    /**
+     * Cancel request
+     */
+    cancel(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<ApiConfiguration>): void;
+}
+export declare function createApiClient(config: ApiConfiguration): ApiClient;

package/dist/types/components/x-form-builder/services/constants/index.d.ts

@@ -0,0 +1,2 @@
+import { FieldType } from '../../types';
+export declare const FORM_INPUT_TYPE: Array<FieldType>;

package/dist/types/components/x-form-builder/services/forms/abstract-control.d.ts

@@ -0,0 +1,59 @@
+import { ValidatorFn, AsyncValidatorFn, ValidationErrors, FormStatus } from './types';
+import { FormGroup } from './form-group';
+import { FormArray } from './form-array';
+export declare abstract class AbstractControl<T = any> {
+    protected _value: T;
+    protected _errors: ValidationErrors | null;
+    protected _status: FormStatus;
+    protected _parent: FormGroup | FormArray | null;
+    protected _validators: ValidatorFn[];
+    protected _asyncValidators: AsyncValidatorFn[];
+    protected _subscribers: Set<(value: T) => void>;
+    protected _touched: boolean;
+    protected _dirty: boolean;
+    constructor(validators?: ValidatorFn[], asyncValidators?: AsyncValidatorFn[]);
+    get value(): T;
+    get errors(): ValidationErrors | null;
+    get status(): FormStatus;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get disabled(): boolean;
+    get parent(): FormGroup | FormArray | null;
+    get touched(): boolean;
+    get untouched(): boolean;
+    get dirty(): boolean;
+    get pristine(): boolean;
+    abstract setValue(value: T, options?: {
+        emitEvent?: boolean;
+    }): void;
+    abstract patchValue(value: T, options?: {
+        emitEvent?: boolean;
+    }): void;
+    abstract reset(value?: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+    protected runValidators(): ValidationErrors | null;
+    protected runAsyncValidators(): Promise<ValidationErrors | null>;
+    updateValueAndValidity(options?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    markAsTouched(): void;
+    markAsUntouched(): void;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    disable(): void;
+    enable(): void;
+    setValidators(validators: ValidatorFn[]): void;
+    setAsyncValidators(validators: AsyncValidatorFn[]): void;
+    clearValidators(): void;
+    clearAsyncValidators(): void;
+    registerValidator(validator: ValidatorFn): void;
+    registerValidatorAsync(validator: AsyncValidatorFn): void;
+    setParent(parent: FormGroup<any> | FormArray<any>): void;
+    subscribe(callback: (value: T) => void): () => void;
+    protected notifySubscribers(): void;
+    setValueInternal(value: any): void;
+    hasError(errorCode: string): boolean;
+    getError(errorCode: string): any;
+}

package/dist/types/components/x-form-builder/services/forms/form-array.d.ts

@@ -0,0 +1,25 @@
+import { AbstractControl } from './abstract-control';
+import { ValidatorFn, AsyncValidatorFn, FormControlOptions } from './types';
+export declare class FormArray<T = any> extends AbstractControl<T[]> {
+    private _controls;
+    constructor(controls: AbstractControl[], validatorsOrOptions?: ValidatorFn[] | FormControlOptions, asyncValidators?: AsyncValidatorFn[]);
+    get controls(): AbstractControl[];
+    get value(): any[];
+    get length(): number;
+    at(index: number): AbstractControl | null;
+    push(control: AbstractControl): void;
+    insert(index: number, control: AbstractControl): void;
+    removeAt(index: number): void;
+    setControl(index: number, control: AbstractControl): void;
+    clear(): void;
+    setValue(value: any[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: any[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    reset(value?: any[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    getRawValue(): any[];
+}

package/dist/types/components/x-form-builder/services/forms/form-builder.d.ts

@@ -0,0 +1,17 @@
+import { FormControl } from './form-control';
+import { FormGroup } from './form-group';
+import { FormArray } from './form-array';
+import { ValidatorFn, AsyncValidatorFn, FormControlOptions } from './types';
+export declare class FormBuilder {
+    control<T = any>(value: T, validatorsOrOptions?: ValidatorFn[] | FormControlOptions, asyncValidators?: AsyncValidatorFn[]): FormControl<T>;
+    group<T extends Record<string, any> = Record<string, any>>(controls: {
+        [key: string]: any;
+    }, options?: {
+        validators?: ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn[];
+    }): FormGroup<T>;
+    array<T = Array<any>>(controls: any[], options?: {
+        validators?: ValidatorFn[];
+        asyncValidators?: AsyncValidatorFn[];
+    }): FormArray<T>;
+}

package/dist/types/components/x-form-builder/services/forms/form-control.d.ts

@@ -0,0 +1,14 @@
+import { AbstractControl } from './abstract-control';
+import { ValidatorFn, AsyncValidatorFn, FormControlOptions } from './types';
+export declare class FormControl<T = any> extends AbstractControl<T> {
+    constructor(initialValue?: any, validatorsOrOptions?: ValidatorFn[] | FormControlOptions, asyncValidators?: AsyncValidatorFn[]);
+    setValue(value: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+    reset(value?: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+}

package/dist/types/components/x-form-builder/services/forms/form-group.d.ts

@@ -0,0 +1,33 @@
+import { AbstractControl } from './abstract-control';
+import { ValidatorFn, AsyncValidatorFn, FormControlOptions } from './types';
+export declare class FormGroup<T extends Record<string, any> = Record<string, any>> extends AbstractControl<T> {
+    private _controls;
+    constructor(controls: {
+        [key: string]: AbstractControl;
+    }, validatorsOrOptions?: ValidatorFn[] | FormControlOptions, asyncValidators?: AsyncValidatorFn[]);
+    get controls(): {
+        [key: string]: AbstractControl<any>;
+    };
+    get value(): T;
+    setValue(value: T, options?: {
+        emitEvent?: boolean;
+    }): void;
+    patchValue(value: Partial<T>, options?: {
+        emitEvent?: boolean;
+    }): void;
+    reset(value?: Partial<T>, options?: {
+        emitEvent?: boolean;
+    }): void;
+    addControl(name: string, control: AbstractControl): void;
+    removeControl(name: string): void;
+    setControl(name: string, control: AbstractControl<any>): void;
+    contains(name: string): boolean;
+    get(path: string | string[]): AbstractControl | null;
+    /**
+     * Override to aggregate validity from child controls
+     */
+    updateValueAndValidity(options?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    getRawValue(): any;
+}

package/dist/types/components/x-form-builder/services/forms/index.d.ts

@@ -0,0 +1,11 @@
+export * from './form-control';
+export * from './form-group';
+export * from './form-array';
+export * from './validators';
+export * from './form-builder';
+export * from './abstract-control';
+export * from './types';
+import { FormArray } from './form-array';
+import { FormControl } from './form-control';
+import { FormGroup } from './form-group';
+export type FormControlType<T extends Record<string, any> = Record<string, any>> = FormControl<any> | FormGroup<T> | FormArray<any>;

package/dist/types/components/x-form-builder/services/forms/types.d.ts

@@ -0,0 +1,11 @@
+export type ValidatorFn = (value: any) => ValidationErrors | null;
+export type AsyncValidatorFn = (value: any) => Promise<ValidationErrors | null>;
+export type ValidationErrors = {
+    [key: string]: any;
+};
+export type FormControlOptions = {
+    validators?: ValidatorFn[];
+    asyncValidators?: AsyncValidatorFn[];
+    updateOn?: 'change' | 'blur' | 'submit';
+};
+export type FormStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';

package/dist/types/components/x-form-builder/services/forms/validators.d.ts

@@ -0,0 +1,16 @@
+import { AbstractControl } from './abstract-control';
+import { ValidatorFn, ValidationErrors } from './types';
+export declare class Validators {
+    static required(control: AbstractControl): ValidationErrors | null;
+    static email(control: AbstractControl): ValidationErrors | null;
+    static min(min: number): ValidatorFn;
+    static max(max: number): ValidatorFn;
+    static minLength(minLength: number): ValidatorFn;
+    static maxLength(maxLength: number): ValidatorFn;
+    static pattern(pattern: string | RegExp): ValidatorFn;
+    static hasUppercase(control: AbstractControl): ValidationErrors | null;
+    static hasNumber(control: AbstractControl): ValidationErrors | null;
+    static hasSpecialChar(control: AbstractControl): ValidationErrors | null;
+    static integer(control: AbstractControl): ValidationErrors | null;
+    static number(control: AbstractControl): ValidationErrors | null;
+}

package/dist/types/components/x-form-builder/services/schema/condition-builder.d.ts

@@ -0,0 +1,39 @@
+import { Condition, ConditionAction, ConditionGroup, AdvancedCondition, ConditionOperator, FormField, Schema } from '../../types';
+import { FormMapping } from './form-mapping';
+import { SchemaBuilder } from './schema-builder';
+export declare class ConditionOperators {
+    get mapping(): Readonly<{
+        [key in ConditionOperator]: (option: Condition, field: FormField, value: any) => boolean;
+    }>;
+    equals(option: Condition, field: FormField, value: any): boolean;
+    notEquals(option: Condition, field: FormField, value: any): boolean;
+    contains(option: Condition, field: FormField, value: any): boolean;
+    greaterThan(option: Condition, field: FormField, value: any): boolean;
+    lessThan(option: Condition, field: FormField, value: any): boolean;
+    isEmpty(_option: Condition, field: FormField, value: any): boolean;
+    isNotEmpty(_option: Condition, field: FormField, value: any): boolean;
+    notContains(option: Condition, field: FormField, value: any): boolean;
+    greaterThanOrEqual(option: Condition, field: FormField, value: any): boolean;
+    lessThanOrEqual(option: Condition, field: FormField, value: any): boolean;
+    startsWith(option: Condition, field: FormField, value: any): boolean;
+    endsWith(option: Condition, field: FormField, value: any): boolean;
+    in(option: Condition, field: FormField, value: any): boolean;
+    notIn(option: Condition, field: FormField, value: any): boolean;
+    run(option: Condition, values: any, context: any): boolean;
+}
+export declare class ConditionBuilder<T extends Record<string, any> = Record<string, any>> extends ConditionOperators {
+    private builder;
+    get form(): FormMapping<T>;
+    get schema(): Schema;
+    get conditions(): Array<Condition | ConditionGroup | AdvancedCondition>;
+    private executors;
+    private isCheckingAll;
+    constructor(builder: SchemaBuilder<T>);
+    checkAll(): void;
+    extract(): void;
+    private getEvaluationValues;
+    group(option: ConditionGroup): void;
+    advanced(option: AdvancedCondition): void;
+    condition(option: Condition): void;
+    execute(action: ConditionAction, actionField: string, value?: any): void;
+}

package/dist/types/components/x-form-builder/services/schema/default-registry.d.ts

@@ -0,0 +1 @@
+export declare function registerDefaultComponents(): void;

package/dist/types/components/x-form-builder/services/schema/form-mapping.d.ts

@@ -0,0 +1,26 @@
+import { FormGroup } from '../forms';
+import { FormField } from '../../types';
+import { SchemaBuilder } from './schema-builder';
+export interface FormMappingOptions {
+    [key: string]: Array<FormMappingOptions | string | Array<any>> | FormMappingOptions | string;
+}
+export declare class FormMapping<T extends Record<string, any> = Record<string, any>> extends FormGroup<T> {
+    private readonly builder;
+    mapping: Map<string, FormField>;
+    mappingById: Map<string, FormField>;
+    mappingObject: FormMappingOptions;
+    private fb;
+    private get schema();
+    is_custom_submit?: boolean;
+    constructor(builder: SchemaBuilder<T>);
+    private toMapping;
+    private toMappingObject;
+    private toFormMapping;
+    private validateOnUseApi;
+    /**
+     * Mark all form controls as touched to trigger validation message display
+     */
+    markAllAsTouched(): void;
+    onSubmit(): void;
+    onReset(): void;
+}

package/dist/types/components/x-form-builder/services/schema/form-registry.d.ts

@@ -0,0 +1,27 @@
+import { FormField, FormAction } from '../../types';
+import { SchemaBuilder } from './schema-builder';
+export interface RenderContext {
+    field: FormField | FormAction;
+    builder: SchemaBuilder<any>;
+    getCommonProps: (field: FormField) => {
+        commonProps: any;
+        onChange: (e: any) => void;
+    };
+    bind: (elements: FormField[], parent?: FormField) => any;
+    emitSubmit: (detail: any) => void;
+    emitError: (detail: any) => void;
+    emitClick: (detail: any) => void;
+    forceUpdate: () => void;
+}
+export type RenderFunction = (context: RenderContext) => any;
+declare class FormRegistryService {
+    private registry;
+    register(type: string, renderFn: RenderFunction): void;
+    getRenderer(type: string): RenderFunction | undefined;
+    render(type: string, context: RenderContext): any;
+    has(type: string): boolean;
+    getRegisteredTypes(): string[];
+    clear(): void;
+}
+export declare const FormRegistry: FormRegistryService;
+export {};

package/dist/types/components/x-form-builder/services/schema/schema-actions.d.ts

@@ -0,0 +1,3 @@
+export declare class schemaActions {
+    constructor();
+}

package/dist/types/components/x-form-builder/services/schema/schema-builder.d.ts

@@ -0,0 +1,19 @@
+import { Events, FormField, Schema, SchemaPlugin } from '../../types';
+import { ConditionBuilder } from './condition-builder';
+import { FormMapping } from './form-mapping';
+export declare class SchemaBuilder<T extends Record<string, any> = Record<string, any>> {
+    readonly schema: Schema;
+    readonly form: FormMapping<T>;
+    context: any;
+    get fields(): ReadonlyArray<FormField>;
+    readonly events: Events<T>;
+    readonly plugins: SchemaPlugin<T>[];
+    private _subscribers;
+    on<K extends keyof Events<T>>(name: K, fn: Events<T>[K]): SchemaBuilder<T>;
+    readonly conditions: ConditionBuilder<T>;
+    constructor(schema: Schema);
+    callEvent<K extends keyof Events<T>>(name: K, ...args: any[]): void;
+    use(plugin: SchemaPlugin<T>, options?: any): Promise<this>;
+    subscribe(callback: (value: T) => void): () => void;
+    protected notifySubscribers(): void;
+}

package/dist/types/components/x-form-builder/services/schema/schema-validator.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from '../../types';
+export declare class SchemaValidator {
+    /**
+     * Validates a schema object and returns an array of error messages.
+     * If the array is empty, the schema is valid.
+     */
+    static validate(schema: Schema): string[];
+    private static validateField;
+}

package/dist/types/components/x-form-builder/types/api/api-common-types.d.ts

@@ -0,0 +1,5 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+export type ApiParameterType = 'text' | 'number' | 'boolean' | 'file';
+export type ApiBodyType = 'none' | 'form-data' | 'x-www-form-urlencoded' | 'raw' | 'binary';
+export type ApiAuthenticationType = 'none' | 'bearer' | 'basic' | 'api-key';
+export type HttpStatusCode = number;

package/dist/types/components/x-form-builder/types/api/api-interfaces.d.ts

@@ -0,0 +1,52 @@
+import { HttpMethod, ApiParameterType, ApiBodyType, ApiAuthenticationType, HttpStatusCode } from './api-common-types';
+export interface ApiHeader {
+    key: string;
+    value: string;
+    description?: string;
+    enabled: boolean;
+}
+export interface ApiParameter {
+    key: string;
+    value: string;
+    type: ApiParameterType;
+    description?: string;
+    required: boolean;
+    enabled: boolean;
+}
+export interface ApiResponse {
+    statusCode: HttpStatusCode;
+    description: string;
+    example: string;
+    headers?: ApiHeader[];
+}
+export interface ApiAuthentication {
+    type: ApiAuthenticationType;
+    token?: string;
+    username?: string;
+    password?: string;
+    apiKey?: string;
+    apiKeyHeader?: string;
+}
+export interface ApiCallbacks {
+    onTimeout?: (response: Response) => void;
+    onError?: (response: Response | Error) => void;
+    onSuccess?: <T = Record<string, any>>(response: Response) => T;
+}
+export interface ApiConfiguration extends ApiCallbacks {
+    id?: string;
+    name: string;
+    description?: string;
+    url: string;
+    method: HttpMethod;
+    headers: ApiHeader[];
+    queryParams: ApiParameter[];
+    bodyType: ApiBodyType;
+    bodyContent?: string;
+    bodyParams?: ApiParameter[];
+    timeout: number;
+    retries: number;
+    authentication?: ApiAuthentication;
+    responses: ApiResponse[];
+    testResponse?: any;
+    isLoading?: boolean;
+}

package/dist/types/components/x-form-builder/types/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api-common-types';
+export * from './api-interfaces';

package/dist/types/components/x-form-builder/types/common/common-types.d.ts

@@ -0,0 +1,49 @@
+export type ThemeMode = 'light' | 'dark' | 'auto';
+export type ComponentSize = 'small' | 'middle' | 'large';
+export type FormControlStatus = 'error' | 'warning' | '';
+export type Alignment = 'left' | 'center' | 'right';
+export type AlignmentExtended = Alignment | 'justify';
+export type VerticalAlignment = 'top' | 'middle' | 'bottom';
+export type ButtonType = 'primary' | 'default' | 'dashed' | 'link' | 'text';
+export type TextStyleType = 'secondary' | 'success' | 'warning' | 'danger';
+export type FlexJustify = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+export type FlexAlign = 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
+export type FlexWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+export type Position = 'static' | 'relative' | 'absolute' | 'fixed' | 'sticky';
+export type Overflow = 'visible' | 'hidden' | 'scroll' | 'auto';
+export type Orientation = 'horizontal' | 'vertical';
+export type Direction = 'row' | 'column';
+export type ResizeMode = 'none' | 'both' | 'horizontal' | 'vertical';
+export type TargetType = '_blank' | '_self' | '_parent' | '_top';
+export type ObjectFit = 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+export type FormLayout = 'horizontal' | 'vertical' | 'inline';
+export type LabelPosition = 'top' | 'left' | 'right';
+export type NotificationPlacement = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'top' | 'bottom';
+export type ExportFormat = 'pdf' | 'excel' | 'csv' | 'json';
+export type CaptchaType = 'recaptcha' | 'hcaptcha' | 'turnstile';
+export type ValidateTrigger = 'onChange' | 'onBlur' | 'onSubmit' | 'manual';
+export type ErrorDisplayType = 'inline' | 'tooltip' | 'notification' | 'modal';
+export type ProgressType = 'steps' | 'percentage' | 'dots';
+export type FormType = 'standard' | 'wizard' | 'stepped' | 'tabbed' | 'accordion' | 'inline' | 'modal' | 'drawer';
+export type MapProvider = 'google' | 'openstreetmap' | 'mapbox' | 'bing';
+export type QRErrorLevel = 'L' | 'M' | 'Q' | 'H';
+export type RenderFormat = 'canvas' | 'svg';
+export type PickerType = 'date' | 'week' | 'month' | 'quarter' | 'year';
+export type FileListType = 'text' | 'picture' | 'picture-card' | 'picture-circle';
+export type TooltipPlacement = 'top' | 'left' | 'right' | 'bottom';
+export type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'hsb';
+export type ExpandTrigger = 'click' | 'hover';
+export type ShowCheckedStrategy = 'SHOW_ALL' | 'SHOW_PARENT' | 'SHOW_CHILD';
+export type CascaderPlacement = 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+export type DatePickerPlacement = 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+export type CascaderVariant = 'outlined' | 'borderless' | 'filled';
+export type SelectionType = 'checkbox' | 'radio';
+export type LoadingType = 'eager' | 'lazy';
+export type ReferrerPolicy = 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export type PanelVariant = 'default' | 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export type ButtonShape = 'circle' | 'round';
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type SubmissionStatus = 'draft' | 'submitted' | 'validated' | 'error';
+export type FileUploadStatus = 'uploading' | 'done' | 'error';
+export type LogicalOperator = 'and' | 'or';
+export type DrawingTool = 'marker' | 'circle' | 'polygon' | 'polyline' | 'rectangle';

package/dist/types/components/x-form-builder/types/common/condition-types.d.ts

@@ -0,0 +1,53 @@
+import { FieldValue } from './value-types';
+import { LogicalOperator } from './common-types';
+export type ConditionOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'isEmpty' | 'isNotEmpty' | 'startsWith' | 'endsWith' | 'in' | 'notIn';
+export type ConditionAction = 'show' | 'hide' | 'enable' | 'disable' | 'require' | 'unrequire' | 'setContent' | 'setLabel';
+export interface ConditionalDisplay {
+    dependsOn: string;
+    condition: Extract<ConditionOperator, 'equals' | 'notEquals' | 'contains' | 'greaterThan' | 'lessThan' | 'isEmpty' | 'isNotEmpty'>;
+    value?: FieldValue;
+    action: Extract<ConditionAction, 'show' | 'hide' | 'enable' | 'disable'>;
+}
+export interface Condition {
+    id: string;
+    field: string;
+    condition: ConditionOperator;
+    value?: FieldValue | FieldValue[];
+    actionField: string | 'all';
+    action: ConditionAction;
+    operator?: LogicalOperator;
+}
+export interface ConditionGroup {
+    id: string;
+    operator: LogicalOperator;
+    conditions: Omit<Condition, 'operator' | 'action' | 'actionField'>[];
+    actions: Array<{
+        actionField: string | 'all';
+        action: ConditionAction;
+    }>;
+}
+export interface FieldCon {
+}
+export interface AdvancedConditionAction {
+    action: ConditionAction;
+    target: string;
+    value?: any;
+}
+export interface AdvancedCondition {
+    id: string;
+    when: {
+        operator: LogicalOperator;
+        rules: Array<{
+            field: string;
+            operator: ConditionOperator;
+            value: any;
+        }>;
+    };
+    then: AdvancedConditionAction[];
+    else?: AdvancedConditionAction[];
+}
+export interface ConditionForm {
+    enabled: boolean;
+    conditions: Condition[];
+    groups?: ConditionGroup[];
+}

package/dist/types/components/x-form-builder/types/common/field-types-enum.d.ts

@@ -0,0 +1,2 @@
+export type FieldType = 'text' | 'email' | 'password' | 'url' | 'number' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'date' | 'datetime' | 'time' | 'file' | 'slider' | 'switch' | 'rate' | 'color' | 'tags' | 'range' | 'phone' | 'location' | 'tree-select' | 'transfer' | 'cascader' | 'auto-complete' | 'divider' | 'heading' | 'paragraph' | 'image' | 'avatar' | 'editor' | 'button' | 'href' | 'grid' | 'table' | 'maps' | 'panel' | 'container' | 'iframe' | 'qr-code' | 'input' | 'daterange' | 'captcha' | 'address';
+export type FieldCategory = 'input' | 'selection' | 'special' | 'controls' | 'layout' | 'display';

package/dist/types/components/x-form-builder/types/common/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common-types';
+export * from './shared-interfaces';
+export * from './field-types-enum';
+export * from './shared-interfaces';
+export * from './validation-types';
+export * from './condition-types';
+export * from './value-types';

package/dist/types/components/x-form-builder/types/common/shared-interfaces.d.ts

@@ -0,0 +1,37 @@
+import { FileUploadStatus } from './common-types';
+export interface Option {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    description?: string;
+    icon?: string;
+}
+export interface FileUploadResult {
+    uid: string;
+    name: string;
+    status: FileUploadStatus;
+    url?: string;
+    size: number;
+    type: string;
+    error?: Error;
+}
+export interface FieldStyle {
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    margin?: string | number;
+    padding?: string | number;
+    className?: string;
+}
+export interface FieldLayout {
+    col?: number;
+    offset?: number;
+    push?: number;
+    pull?: number;
+    span?: number;
+}
+export interface ExtendField {
+    classList?: string[];
+    margin?: string;
+    padding?: string;
+}

package/dist/types/components/x-form-builder/types/common/validation-types.d.ts

@@ -0,0 +1,36 @@
+type ResourceKey = string;
+import { FieldValue } from './value-types';
+export type ValidationType = 'required' | 'pattern' | 'minLength' | 'maxLength' | 'min' | 'max' | 'hasUppercase' | 'hasNumber' | 'hasSpecialChar' | 'integer' | 'number' | 'custom';
+export interface ValidationRule<T = FieldValue> {
+    type: ValidationType;
+    value?: string | number | RegExp;
+    message: string;
+    validator?: (value: T) => boolean | Promise<boolean>;
+}
+/**
+ * Structured validator config for the `validators` array field.
+ * Example:
+ * validators: [
+ *   { type: 'required' },
+ *   { type: 'minLength', value: 5 },
+ *   { type: 'maxLength', value: 10 },
+ *   { type: 'pattern', value: '[0-9]*' },
+ *   { type: 'hasUppercase' },
+ *   { type: 'hasNumber' },
+ *   { type: 'hasSpecialChar' },
+ * ]
+ */
+export interface ValidatorConfig {
+    type: ValidationType;
+    value?: string | number;
+    message?: string;
+}
+export interface ValidationMessages {
+    [key: string]: string | ResourceKey;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+export {};