@sdcorejs/angular 19.0.0-rc.1

package/components/form-generic/src/components/form-render/components/item/item.component.d.ts

@@ -0,0 +1,32 @@
+import { FormGroup } from '@angular/forms';
+import { SdCustomValidator } from '@sdcorejs/angular/forms/models';
+import { SdFormGenericComponent } from '../../../../models';
+import { TableComponent, UploadComponent } from './components';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class LibItemComponent {
+    itemUpload?: UploadComponent;
+    itemTable?: TableComponent;
+    setVariables: Subject<{
+        key: string;
+        value: any;
+    }>;
+    form: FormGroup<{}>;
+    value: any;
+    entity: Record<string, any>;
+    set _entity(val: Record<string, any>);
+    col: string;
+    component?: SdFormGenericComponent;
+    set _component(val: SdFormGenericComponent);
+    disabled: boolean;
+    set _disabled(val: boolean | '' | undefined);
+    required: boolean;
+    set _required(val: boolean | '' | undefined);
+    viewed: boolean;
+    set _viewed(val: boolean | '' | undefined);
+    validator?: SdCustomValidator;
+    set _validator(validator: SdCustomValidator);
+    upload: () => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LibItemComponent, "lib-item", never, { "setVariables": { "alias": "setVariables"; "required": true; }; "form": { "alias": "form"; "required": false; }; "_entity": { "alias": "entity"; "required": true; }; "_component": { "alias": "component"; "required": true; }; "_disabled": { "alias": "disabled"; "required": false; }; "_required": { "alias": "required"; "required": false; }; "_viewed": { "alias": "viewed"; "required": false; }; "_validator": { "alias": "validator"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/form-generic/src/components/form-render/components/variable/variable.component.d.ts

@@ -0,0 +1,22 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { SdFormGenericVariable } from '../../../../models';
+import * as i0 from "@angular/core";
+export declare class VariableComponent {
+    #private;
+    private ref;
+    variables?: SdFormGenericVariable[];
+    setVariables: Subject<{
+        key: string;
+        value: any;
+    }>;
+    form: FormGroup<any>;
+    entity: Record<string, any>;
+    set _entity(val: Record<string, any>);
+    constructor(ref: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VariableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VariableComponent, "variable", never, { "variables": { "alias": "variables"; "required": true; }; "setVariables": { "alias": "setVariables"; "required": true; }; "form": { "alias": "form"; "required": false; }; "_entity": { "alias": "entity"; "required": true; }; }, {}, never, never, true, never>;
+}

package/components/form-generic/src/components/form-render/form-render.component.d.ts

@@ -0,0 +1,39 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, QueryList } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
+import { Subject } from 'rxjs';
+import { ISdFormGenericConfiguration } from '../../configurations';
+import { SdFormRenderConfiguration } from '../../models';
+import { SdFormGenericValidation } from '../../models/form-generic-validation.model';
+import { LibItemComponent } from './components';
+import * as i0 from "@angular/core";
+export declare class SdFormRender extends SdBaseSecureComponent implements OnDestroy, AfterViewInit {
+    #private;
+    private ref;
+    private formGenericConfiguration;
+    formRenderItems: QueryList<LibItemComponent>;
+    form: FormGroup;
+    configuration: SdFormRenderConfiguration;
+    set _configuration(val: SdFormRenderConfiguration);
+    set _default(defaultEntity: Record<string, any>);
+    entity: Record<string, any>;
+    set _entity(val: Record<string, any>);
+    properties: string[];
+    set _properties(val: string[]);
+    viewed: boolean;
+    set _viewed(val: boolean | '');
+    loadCompleted: boolean;
+    hashedValues?: string;
+    formValue: Record<string, any>;
+    setVariables: Subject<{
+        key: string;
+        value: any;
+    }>;
+    constructor(ref: ChangeDetectorRef, formGenericConfiguration: ISdFormGenericConfiguration | null);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    upload: () => Promise<void>;
+    getValidationMessages: (alert: SdFormGenericValidation["alert"]) => Promise<string[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdFormRender, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdFormRender, "sd-form-render", never, { "form": { "alias": "form"; "required": false; }; "_configuration": { "alias": "configuration"; "required": true; }; "_default": { "alias": "defaultEntity"; "required": false; }; "_entity": { "alias": "entity"; "required": false; }; "_properties": { "alias": "properties"; "required": false; }; "_viewed": { "alias": "viewed"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/form-generic/src/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './form-builder/form-builder.component';
+export * from './form-render/form-render.component';
+export * from './sd-feel-expression/sd-feel-expression.component';

package/components/form-generic/src/components/sd-feel-expression/sd-feel-expression.component.d.ts

@@ -0,0 +1,43 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
+import { SdModal } from '@sdcorejs/angular/components/modal';
+import { Attribute, SdFormGenericComponent, SdFormGenericExpression, SdFormGenericGroup } from '../../models';
+import { ExpressionFeelPipe } from '../../pipes';
+import { FormGenericService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class SdFeelExpression extends SdBaseSecureComponent {
+    #private;
+    private ref;
+    private expressionFeelPipe;
+    private formGenericService;
+    modal?: SdModal;
+    form: FormGroup<{}>;
+    attributeOperators: Record<"string" | "number" | "boolean" | "datetime" | "values", {
+        value: import("@sdcorejs/angular/components/form-generic").Operator;
+        symbol?: string;
+        display: string;
+    }[]>;
+    attributes: Attribute[];
+    attribute: Record<string, Attribute>;
+    components: (SdFormGenericComponent | SdFormGenericGroup)[];
+    expression?: SdFormGenericExpression;
+    set _expression(expression: SdFormGenericExpression | undefined);
+    expressionChange: EventEmitter<SdFormGenericExpression>;
+    model?: string;
+    set _model(model: string | undefined);
+    modelChange: EventEmitter<string>;
+    sdChange: EventEmitter<{
+        model?: string;
+        expression?: SdFormGenericExpression;
+    }>;
+    constructor(ref: ChangeDetectorRef, expressionFeelPipe: ExpressionFeelPipe, formGenericService: FormGenericService);
+    ngOnInit(): void;
+    edit: () => Promise<void>;
+    addCondition: (conditions: SdFormGenericExpression["conditions"]) => void;
+    addCombinator: (conditions: SdFormGenericExpression["conditions"]) => void;
+    remove: (conditions: SdFormGenericExpression["conditions"], idx: number) => void;
+    onAccept: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdFeelExpression, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdFeelExpression, "sd-feel-expression", never, { "components": { "alias": "components"; "required": true; }; "_expression": { "alias": "expression"; "required": true; }; "_model": { "alias": "model"; "required": true; }; }, { "expressionChange": "expressionChange"; "modelChange": "modelChange"; "sdChange": "sdChange"; }, never, never, true, never>;
+}

package/components/form-generic/src/configurations/form-generic.configuration.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+import { IWorkflowConfigurationForm } from './form.configuration';
+export interface ISdFormGenericConfiguration {
+    form?: IWorkflowConfigurationForm;
+}
+export declare const SD_FORM_GENERIC_CONFIGURATION: InjectionToken<ISdFormGenericConfiguration>;

package/components/form-generic/src/configurations/form.configuration.d.ts

@@ -0,0 +1,12 @@
+import { SdSearch } from '@sdcorejs/angular/forms/models';
+import { SdFormGenericArgs, SdFormGenericDefinitionHtml, SdFormGenericDefinitionSelection, SdFormGenericDefinitionTable, SdFormGenericSelectionItem, SdFormGenericTemplate } from '../models';
+import { SdFormGenericValidationConfiguration } from '../models/form-generic-validation.model';
+export interface IWorkflowConfigurationForm<TSelectionArgs = any> {
+    templates: SdFormGenericTemplate[];
+    selections: SdFormGenericDefinitionSelection<any, TSelectionArgs>[] | (() => SdFormGenericDefinitionSelection<any, TSelectionArgs>[]) | (() => Promise<SdFormGenericDefinitionSelection[]>);
+    getValues?: (key: string, selectionArgs?: TSelectionArgs) => Promise<SdFormGenericSelectionItem[]>;
+    getLazyValues?: (key: string, selectionArgs?: TSelectionArgs) => ((searchArgs: Parameters<SdSearch>[0], args: SdFormGenericArgs) => Promise<SdFormGenericSelectionItem[]>);
+    tables: SdFormGenericDefinitionTable[];
+    htmls: SdFormGenericDefinitionHtml[] | (() => SdFormGenericDefinitionHtml[]) | (() => Promise<SdFormGenericDefinitionHtml[]>);
+    validation?: SdFormGenericValidationConfiguration;
+}

package/components/form-generic/src/configurations/index.d.ts

@@ -0,0 +1,2 @@
+export * from './form-generic.configuration';
+export * from './form.configuration';

package/components/form-generic/src/models/form-generic-component.model.d.ts

@@ -0,0 +1,318 @@
+import { SdTableColumn, SdTableOption } from '@sdcorejs/angular/components/table';
+import { SdUploadFile } from '@sdcorejs/angular/components/upload-file';
+import { Color, ValidationPatternType } from '@sdcorejs/utils/models';
+import { SdFormGenericSelectionStaticItem } from './form-generic-definition-selection.model';
+import { SdFormGenericExpression } from './form-generic-expression.model';
+import { SdFormGeneric } from './form-generic.model';
+import { SdUnwrapSignal } from '@sdcorejs/angular/utilities/models';
+export interface SdFormRenderConfiguration {
+    onLoaded?: () => void;
+    components: SdFormGeneric['components'];
+    validations?: SdFormGeneric['validations'];
+    variables?: SdFormGenericVariable[];
+    beforeSubmit?: (entity: Record<string, any>) => Promise<Record<string, any>>;
+}
+export interface SdFormGenericLayout {
+    row?: string;
+    columns: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    mobileColumns?: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+}
+export declare const GenerateId: () => string;
+export declare const GenerateKey: () => string;
+export declare const SdFormatComponent: (component: SdFormGenericComponent | SdFormGenericGroup) => void;
+export interface SdFormGenericVariable {
+    id: string;
+    key: string;
+    label: string;
+}
+export type SdFormGenericComponent = SdFormGenericTextfield | SdFormGenericChipString | SdFormGenericChipCalendar | SdFormGenericTextarea | SdFormGenericNumber | SdFormGenericCheckbox | SdFormGenericDatetime | SdFormGenericValues | SdFormGenericUpload | SdFormGenericTable | SdFormGenericHtml | SdFormGenericBreak;
+export type SdFormGenericValues = SdFormGenericRadio | SdFormGenericSelect | SdFormGenericChecklist;
+export interface SdFormGenericComponentBase {
+    template?: string;
+    id: string;
+    key: string;
+    label: string;
+    helperText?: string;
+    layout?: SdFormGenericLayout;
+    validate?: {
+        required?: boolean;
+    };
+    disabled?: boolean;
+    properties?: {
+        viewed?: boolean;
+        hyperlink?: string;
+        hidden?: boolean;
+        hiddenWhenExpression?: SdFormGenericExpression;
+        visibleWhenExpression?: SdFormGenericExpression;
+        disabledWhenExpression?: SdFormGenericExpression;
+        requiredWhenExpression?: SdFormGenericExpression;
+        onChange?: {
+            setValues?: Record<string, any>;
+        };
+    } & Record<string, any>;
+}
+export interface SdFormGenericTextfield extends SdFormGenericComponentBase {
+    type: 'textfield';
+    defaultValue?: string;
+    validate?: {
+        maxlength?: number;
+        minlength?: number;
+        pattern?: ValidationPatternType | string;
+        patternErrorMessage?: string;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericChipString extends SdFormGenericComponentBase {
+    type: 'chip-string';
+    defaultValue?: string[];
+    validate?: {
+        maxlength?: number;
+        minlength?: number;
+        pattern?: ValidationPatternType | string;
+        patternErrorMessage?: string;
+        maxOfItems?: number;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericChipCalendar extends SdFormGenericComponentBase {
+    type: 'chip-calendar';
+    defaultValue?: string[];
+    validate?: {
+        maxlength?: number;
+        minlength?: number;
+        pattern?: ValidationPatternType | string;
+        patternErrorMessage?: string;
+        maxOfItems?: number;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericTextarea extends SdFormGenericComponentBase {
+    type: 'textarea';
+    defaultValue?: string;
+    validate?: {
+        maxlength?: number;
+        minlength?: number;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericNumber extends SdFormGenericComponentBase {
+    type: 'number';
+    defaultValue?: number;
+    validate?: {
+        min?: number;
+        max?: number;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericCheckbox extends SdFormGenericComponentBase {
+    type: 'checkbox';
+    defaultValue?: boolean;
+}
+export interface SdFormGenericDatetime extends SdFormGenericComponentBase {
+    type: 'datetime';
+    subtype: 'date' | 'datetime';
+    defaultValue?: string;
+    validate?: {
+        min?: 'TODAY' | string;
+        max?: 'TODAY' | string;
+    } & SdFormGenericComponentBase['validate'];
+}
+export interface SdFormGenericRadio extends SdFormGenericComponentBase {
+    type: 'radio';
+    values?: SdFormGenericSelectionStaticItem[];
+    valuesKey?: string;
+    defaultValue?: string;
+    properties?: {
+        direction?: 'row' | 'column';
+    } & SdFormGenericComponentBase['properties'];
+}
+export interface SdFormGenericSelect extends SdFormGenericComponentBase {
+    type: 'select';
+    values?: SdFormGenericSelectionStaticItem[];
+    valuesKey?: string;
+    defaultValue?: string | string[];
+    properties?: {
+        query?: Record<string, any>;
+        multiple?: boolean;
+        setVariables?: Record<string, string>;
+    } & SdFormGenericComponentBase['properties'];
+}
+export interface SdFormGenericChecklist extends SdFormGenericComponentBase {
+    type: 'checklist';
+    values?: SdFormGenericSelectionStaticItem[];
+    valuesKey?: string;
+    defaultValue?: string[];
+    properties?: {
+        query?: Record<string, any>;
+    } & SdFormGenericComponentBase['properties'];
+}
+export interface SdFormGenericGroup {
+    id: string;
+    type: 'group';
+    label: string;
+    layout: SdFormGenericLayout;
+    components: SdFormGenericComponent[];
+    properties: {
+        icon: string;
+        color: Color;
+        hidden?: boolean;
+        hiddenWhenExpression?: SdFormGenericExpression;
+        visibleWhenExpression?: SdFormGenericExpression;
+    };
+}
+export interface SdFormGenericUpload extends SdFormGenericComponentBase {
+    type: 'upload';
+    properties?: {
+        type?: SdUnwrapSignal<SdUploadFile['type']>;
+        maxSize?: SdUnwrapSignal<SdUploadFile['maxSize']>;
+        max?: SdUnwrapSignal<SdUploadFile['max']>;
+        extensions?: SdUnwrapSignal<SdUploadFile['extensions']>;
+        args?: Record<string, any>;
+        source?: 'ALL' | 'PHOTO_LIBRARY' | 'CAPTURE';
+    } & SdFormGenericComponentBase['properties'];
+}
+export interface FormRenderComponentTableColumnValues {
+    valuesKey: string;
+    query?: Record<string, any>;
+}
+export type SdFormGenericTableColumn<T = any> = TableColumnString<T> | TableColumnNumber<T> | TableColumnBool<T> | TableColumnDate<T> | TableColumnDatetime<T> | TableColumnRadio<T> | TableColumnValues<T> | TableColumnImage<T> | TableColumnFile<T>;
+export declare const TableColumnTypes: {
+    value: string;
+    display: string;
+}[];
+interface TableColumnBase<T = any> {
+    key: Extract<keyof T, string>;
+    label: string;
+    width?: SdTableColumn['width'];
+    validate?: {
+        required?: boolean;
+    };
+}
+interface TableColumnString<T = any> extends TableColumnBase<T> {
+    type: 'string';
+    validate?: {
+        minlength?: number;
+        maxlength?: number;
+        pattern?: string;
+        patternErrorMessage?: string;
+    } & TableColumnBase['validate'];
+}
+interface TableColumnNumber<T = any> extends TableColumnBase<T> {
+    type: 'number';
+    validate?: {
+        min?: number;
+        max?: number;
+    } & TableColumnBase['validate'];
+}
+interface TableColumnDate<T = any> extends TableColumnBase<T> {
+    type: 'date';
+    validate?: {
+        min?: 'TODAY' | string;
+        max?: 'TODAY' | string;
+    } & TableColumnBase['validate'];
+}
+interface TableColumnDatetime<T = any> extends TableColumnBase<T> {
+    type: 'datetime';
+    validate?: {
+        min?: 'TODAY' | string;
+        max?: 'TODAY' | string;
+    } & TableColumnBase['validate'];
+}
+interface TableColumnBool<T = any> extends TableColumnBase<T> {
+    type: 'boolean';
+    displayOnTrue?: string;
+    displayOnFalse?: string;
+}
+interface TableColumnRadio<T = any> extends TableColumnBase<T> {
+    type: 'radio';
+    values?: SdFormGenericSelectionStaticItem[];
+}
+interface TableColumnValues<T = any> extends TableColumnBase<T> {
+    type: 'values';
+    valuesKey: string;
+    query?: Record<string, any>;
+    values?: SdFormGenericSelectionStaticItem[];
+}
+interface TableColumnImage<T = any> extends TableColumnBase<T> {
+    type: 'image';
+    args?: Record<string, any>;
+    validate?: {
+        max?: number;
+        maxSize?: number;
+    } & TableColumnBase['validate'];
+}
+interface TableColumnFile<T = any> extends TableColumnBase<T> {
+    type: 'file';
+    args?: Record<string, any>;
+    validate?: {
+        max?: number;
+        maxSize?: number;
+    } & TableColumnBase['validate'];
+}
+export interface SdFormGenericTable extends SdFormGenericComponentBase {
+    type: 'table';
+    columnsKey?: string;
+    columns?: SdFormGenericTableColumn[];
+    properties?: {
+        type?: SdTableOption['type'];
+        titleButtonCreate?: string;
+    } & SdFormGenericComponentBase['properties'];
+}
+/**
+ * Break component — invisible runtime element ép xuống dòng mới. Dùng khi layout có
+ * vùng cố định và việc ẩn/hiện trường khác không nên xáo trộn vị trí các trường còn lại.
+ * Ở canvas (design) render thanh ngang mảnh; ở runtime render empty 12-col cell.
+ *
+ * Extend SdFormGenericComponentBase để tương thích với union narrowing trong các pipe/render
+ * (key, validate, disabled, properties full) — runtime sẽ ignore mọi field ngoài id/type/layout.
+ */
+export interface SdFormGenericBreak extends SdFormGenericComponentBase {
+    type: 'break';
+}
+export interface SdFormGenericHtml {
+    template?: string;
+    id: string;
+    key?: string;
+    type: 'html';
+    content: string;
+    validate?: {
+        required?: boolean;
+    };
+    layout?: SdFormGenericLayout;
+    properties?: {
+        viewed?: boolean;
+        hyperlink?: string;
+        hidden?: boolean;
+        hiddenWhenExpression?: SdFormGenericExpression;
+        visibleWhenExpression?: SdFormGenericExpression;
+        variables?: {
+            key: string;
+            label: string;
+            value?: string;
+        }[];
+        queries?: {
+            key: string;
+            label: string;
+        }[];
+        query?: Record<string, any>;
+    };
+}
+export type FormBuilderComponentGroup = 'basic' | 'choice' | 'advanced' | 'layout';
+export interface FormBuilderComponent {
+    type: string;
+    /** Material Symbols Rounded icon name. Rendered via <span class="msi">{symbol}</span>. */
+    symbol: string;
+    /** Category group for the left palette grouping. */
+    group: FormBuilderComponentGroup;
+    name: string;
+}
+export declare const FormBuilderComponents: FormBuilderComponent[];
+/** Lookup: component type → Material Symbol + label, used by attribute panel header. */
+export declare const COMPONENT_ICONS: Record<string, {
+    symbol: string;
+    label: string;
+}>;
+export declare const GetComponentAttributes: (components: (SdFormGenericComponent | SdFormGenericGroup)[]) => {
+    value: string;
+    display: string;
+}[];
+export declare const GetVariableAttributes: (variables: SdFormGenericVariable[]) => {
+    value: string;
+    display: string;
+}[];
+export {};

package/components/form-generic/src/models/form-generic-definition-html.model.d.ts

@@ -0,0 +1,28 @@
+export type SdFormGenericDefinitionHtml = SdFormGenericDefinitionHtmlStatic | SdFormGenericDefinitionHtmlQuery;
+interface SdFormGenericDefinitionHtmlStatic {
+    type: 'static';
+    value: string;
+    display: string;
+    content: string;
+    variables?: {
+        key: string;
+        label: string;
+        value?: string;
+    }[];
+}
+interface SdFormGenericDefinitionHtmlQuery {
+    type: 'query';
+    value: string;
+    display: string;
+    queries: {
+        key: string;
+        label: string;
+    }[];
+    content: (query?: Record<string, any>) => Promise<string>;
+    variables?: {
+        key: string;
+        label: string;
+        value?: string;
+    }[];
+}
+export {};

package/components/form-generic/src/models/form-generic-definition-selection.model.d.ts

@@ -0,0 +1,49 @@
+import { SdSearch } from '@sdcorejs/angular/forms/models';
+import { SdFormGenericArgs } from './form-render/form-render-args.model';
+export interface SdFormGenericSelectionItem<T = any> {
+    value: string;
+    display: string;
+    disabled?: boolean;
+    template?: string;
+    data?: T;
+}
+export interface SdFormGenericSelectionStaticItem {
+    value: string;
+    label: string;
+}
+export type SdFormGenericDefinitionSelection<T = any, TArgs = any> = SelectionValues<T> | SelectionLazyValues<T> | SelectionValuesKey<TArgs> | SelectionLazyValuesKey<TArgs>;
+interface SelectionVariables<T = any> {
+    items?: {
+        value: Extract<keyof T, string>;
+        display: string;
+    }[];
+    detail?: (values: string | number | string[] | number[], args: SdFormGenericArgs) => Promise<T | undefined>;
+}
+interface SelectionQueries {
+    items?: {
+        value: string;
+        display: string;
+    }[];
+}
+interface SelecttionBase {
+    value: string;
+    display: string;
+    viewed?: (values: (string | number)[], args: SdFormGenericArgs) => Promise<string>;
+    queries?: SelectionQueries;
+    variables?: SelectionVariables;
+}
+interface SelectionValuesKey<TArgs> extends SelecttionBase {
+    valuesKey: string;
+    args?: TArgs;
+}
+interface SelectionLazyValuesKey<TArgs> extends SelecttionBase {
+    lazyValuesKey: string;
+    args?: TArgs;
+}
+interface SelectionValues<T = any> extends SelecttionBase {
+    values: (args: SdFormGenericArgs) => Promise<SdFormGenericSelectionItem<T>[]>;
+}
+interface SelectionLazyValues<T = any> extends SelecttionBase {
+    lazyValues: (searchArgs: Parameters<SdSearch>[0], args: SdFormGenericArgs) => Promise<SdFormGenericSelectionItem<T>[]>;
+}
+export {};

package/components/form-generic/src/models/form-generic-definition-table.model.d.ts

@@ -0,0 +1,6 @@
+import { SdFormGenericTableColumn } from './form-generic-component.model';
+export interface SdFormGenericDefinitionTable<T = any> {
+    value: string;
+    display: string;
+    columns: () => SdFormGenericTableColumn<T>[];
+}

package/components/form-generic/src/models/form-generic-expression.model.d.ts

@@ -0,0 +1,74 @@
+import { Operator as SdOperator } from '@sdcorejs/utils/models';
+import { SdFormGenericComponent, SdFormGenericGroup } from './form-generic-component.model';
+export interface SdFormGenericExpression {
+    key: string;
+    type: 'combinator';
+    combinator: '&&' | '||';
+    conditions: (SdFormGenericExpression | SdFormGenericExpressionCondition)[];
+}
+export interface SdFormGenericExpressionCondition {
+    key: string;
+    type: 'condition';
+    field?: string;
+    operator: SdOperator;
+    value: any;
+    dayInfo: DayInfo;
+}
+export type Operator = 'EQUAL' | 'NOT_EQUAL' | 'GREATER_THAN' | 'LESS_THAN' | 'GREATER_OR_EQUAL' | 'LESS_OR_EQUAL' | 'NULL' | 'NOT_NULL';
+export declare const Operators: {
+    value: Operator;
+    symbol?: string;
+    display: string;
+}[];
+export type Attribute = AttributeBase | AttributeBoolean | AttributeDate | AttributeValues;
+interface AttributeBase {
+    value: string;
+    display: string;
+    type: 'string' | 'number';
+}
+interface AttributeBoolean {
+    value: string;
+    display: string;
+    type: 'boolean';
+    displayOnTrue: string;
+    displayOnFalse: string;
+}
+interface AttributeDate {
+    value: string;
+    display: string;
+    type: 'datetime';
+}
+export interface DayInfo {
+    type?: 'RELATED' | 'NOW' | 'DATETIME' | 'ATTRIBUTE';
+    related?: 'LASTDAY' | 'NEXTDAY' | 'LASTWEEK' | 'NEXTWEEK' | 'LASTMONTH' | 'NEXTMONTH';
+    relatedValue?: number;
+}
+export declare const DayInfoTypes: {
+    value: string;
+    display: string;
+}[];
+export declare const DayInfoPreviouses: {
+    value: string;
+    display: string;
+    format: (n: number) => string;
+}[];
+export declare const GetDatetimeValue: (value: string) => string | undefined;
+interface AttributeValues {
+    value: string;
+    display: string;
+    type: 'values';
+    values: {
+        value: string;
+        display: string;
+    }[];
+}
+export declare const AttributeOperators: Record<Attribute['type'], {
+    value: Operator;
+    symbol?: string;
+    display: string;
+}[]>;
+export declare const GetAttributes: (components: (SdFormGenericComponent | SdFormGenericGroup)[]) => Attribute[];
+export declare const TemplateToCondition: (template: string | undefined | null, entity: Record<string, any>) => string | undefined;
+export declare const EvaluateExpression: (condition: SdFormGenericExpression | SdFormGenericExpressionCondition, entity: Record<string, any>) => boolean | undefined;
+export declare const ExpressionToJavascriptExpression: (condition: SdFormGenericExpression | SdFormGenericExpressionCondition) => string | undefined;
+export {};

package/components/form-generic/src/models/form-generic-template.model.d.ts

@@ -0,0 +1,6 @@
+import { SdFormGenericComponent, SdFormGenericHtml } from './form-generic-component.model';
+export interface SdFormGenericTemplate {
+    value: string;
+    display: string;
+    component: Exclude<SdFormGenericComponent, SdFormGenericHtml>;
+}