special-forms 18.0.1 → 20.0.0-SNAPSHOT

package/index.d.ts

@@ -1,5 +1,586 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="special-forms" />
-export * from './public-api';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { Observable, Subscription } from 'rxjs';
+import { ValidatorFn, AsyncValidatorFn, AbstractControl, FormControl, FormGroup, FormArray } from '@angular/forms';
+import { InputmaskOptions } from '@ngneat/input-mask';
+import { ThemePalette, ErrorStateMatcher } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, ViewContainerRef, PipeTransform } from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i4 from '@angular/material/button';
+import { Editor, Toolbar } from 'ngx-editor';
+
+declare enum EControlTypes {
+    pkey = "PRIMARY-KEY",
+    input = "INPUT",
+    richText = "RICH-TEXT",
+    textArea = "TEXT-AREA",
+    dropdown = "DROPDOWN",
+    date = "DATE",
+    checkbox = "CHECKBOX",
+    upload = "UPLOAD",
+    autocomplete = "AUTOCOMPLETE",
+    multiple = "MULTIPLE-AUTOCOMPLETE",
+    array = "ARRAY",
+    form = "FORM",
+    label = "LABEL",
+    default = "DEFAULT"
+}
+
+interface IFieldBasicData {
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    length: number;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    disabled: boolean;
+    errorMessages: {
+        [key: string]: string;
+    };
+}
+interface IFieldData extends IFieldBasicData {
+    validators: ValidatorFn | ValidatorFn[] | null;
+    asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null;
+    defaultValue: any;
+}
+
+interface IAutocompleteSettings<T> {
+    getData: (query: string, control?: AbstractControl) => void;
+    source: Observable<T[]>;
+    fieldId: string;
+    icon?: string;
+    iconAction?: (data: T) => void;
+    onSelect?: (data: T) => void;
+    fieldName: string | ((a?: T) => string);
+    fieldImage?: string | ((a?: T) => string);
+}
+interface IAutocompleteField<T = any> extends IFieldData {
+    settings: IAutocompleteSettings<T>;
+    type: EControlTypes.autocomplete;
+    defaultValue: T;
+}
+
+interface IDatePickerSettings {
+    lowerLimit?: number;
+    upperLimit?: number;
+    startAt?: Date;
+}
+interface IDatePickerField extends IFieldData {
+    settings: IDatePickerSettings;
+    type: EControlTypes.date;
+    defaultValue: string;
+}
+
+interface IDropdownSettings {
+    icon?: string;
+    onSelect?: (data: any) => void;
+    iconAction?: (data: any) => void;
+    source: Observable<any[]>;
+    fieldId: string;
+    fieldName: string | ((a?: any) => string);
+    notSelectedText?: string;
+}
+interface IDropdownField extends IFieldData {
+    settings: IDropdownSettings;
+    type: EControlTypes.dropdown;
+    defaultValue: string;
+}
+
+declare const InputTypes: readonly ["color", "date", "datetime-local", "email", "month", "number", "password", "search", "tel", "text", "time", "url", "week"];
+type TInputTypes = typeof InputTypes[number];
+
+type IInputSettings = {
+    type?: TInputTypes;
+    mask?: InputmaskOptions<any>;
+    withCounter?: boolean;
+    withMaxlength?: boolean;
+    icon?: string;
+    iconAction?: (data: string) => void;
+    onEnter?: (data: string) => void;
+    onBlur?: (data: string) => void;
+};
+interface IInputField extends IFieldData {
+    settings: IInputSettings;
+    type: EControlTypes.input;
+    defaultValue: string;
+}
+
+interface ICheckboxSettings {
+    labelPosition?: 'before' | 'after';
+    indeterminate?: boolean;
+    color?: ThemePalette;
+}
+interface ICheckboxField extends IFieldData {
+    settings: ICheckboxSettings;
+    type: EControlTypes.checkbox;
+    defaultValue: boolean;
+}
+
+type IMultipleAutocompleteSettings<T> = {
+    getData: (query: string, control?: AbstractControl) => void;
+    source: Observable<T[]>;
+    fieldId: string;
+    icon?: string;
+    iconAction?: (data: T) => void;
+    onSelect?: (data: T) => void;
+    fieldName: string | ((a?: T) => string);
+    fieldImage?: string | ((a?: T) => string);
+};
+interface IMultipleAutocompleteField<T = any> extends IFieldData {
+    settings: IMultipleAutocompleteSettings<T>;
+    type: EControlTypes.multiple;
+    defaultValue: any;
+}
+
+type ITextAreaSettings = {
+    withCounter?: boolean;
+    withMaxlength?: boolean;
+};
+interface ITextAreaField extends IFieldData {
+    settings: ITextAreaSettings;
+    type: EControlTypes.textArea;
+    defaultValue: string;
+}
+
+type IUploadSettings = {
+    accept?: string;
+    multiple?: boolean;
+    minSize?: number;
+    maxSize?: number;
+    mode?: 'replace' | 'append';
+    onSelectFile?: (value: File[] | File) => void;
+};
+interface IUploadField extends IFieldData {
+    settings: IUploadSettings;
+    type: EControlTypes.upload;
+    defaultValue: any;
+}
+
+type ILabelSettings = {
+    pipe?: (value: any) => string;
+    stylesPipe?: (value: any) => string;
+    isLink: boolean;
+    onClickLink?: (value: any) => void;
+};
+interface ILabelField extends IFieldData {
+    settings: ILabelSettings;
+    type: EControlTypes.label;
+    defaultValue: string;
+}
+
+interface IRichTextSettings {
+    colorPresets?: string[];
+    outputFormat?: 'doc' | 'html';
+}
+interface IRichTextField extends IFieldData {
+    settings: IRichTextSettings;
+    type: EControlTypes.richText;
+    defaultValue: string;
+}
+
+interface IcontrolName {
+    name: string;
+}
+type IFormSettings<T extends IFormStructure = IFormStructure> = {
+    formFields: T;
+};
+interface IFormField<TValue = any, TFields extends IFormStructure = IFormStructure> extends IFieldData {
+    settings: IFormSettings<TFields>;
+    type: EControlTypes.form;
+    defaultValue: TValue;
+}
+type IArraySettings<TFields extends IFormStructure = IFormStructure> = {
+    addActionLabel?: string;
+    removeActionLabel?: string;
+    formFields: TFields;
+    withFormHeader?: boolean;
+    withActionButtons?: boolean;
+};
+interface IArrayField<TValue = any, TFields extends IFormStructure = IFormStructure> extends IFieldData {
+    settings: IArraySettings<TFields>;
+    type: EControlTypes.array;
+    defaultValue: TValue[];
+}
+interface IPkeyField<T = any> extends IFieldData {
+    settings: any;
+    type: EControlTypes.pkey;
+    defaultValue: any;
+}
+interface IDefaultField extends IFieldData {
+    settings: any;
+    type: EControlTypes.default;
+    defaultValue: any;
+}
+type TRawFields = IDefaultField | IInputField | IRichTextField | IDropdownField | IArrayField | IFormField | IAutocompleteField | IMultipleAutocompleteField | IDatePickerField | ITextAreaField | IUploadField | ILabelField | IPkeyField | ICheckboxField;
+type TSpecialInput = IInputField & IcontrolName;
+type TSpecialDefault = IDefaultField & IcontrolName;
+type TSpecialDropdown = IDropdownField & IcontrolName;
+type TSpecialArray = IArrayField & IcontrolName;
+type TSpecialForm = IFormField & IcontrolName;
+type TSpecialRichText = IRichTextField & IcontrolName;
+type TSpecialAutocomplete = IAutocompleteField & IcontrolName;
+type TSpecialDatepicker = IDatePickerField & IcontrolName;
+type ISpecialCheckbox = ICheckboxField & IcontrolName;
+type ISpecialTextArea = ITextAreaField & IcontrolName;
+type ISpecialLabel = ILabelField & IcontrolName;
+type ISpecialUpload = IUploadField & IcontrolName;
+type ISpecialPkey = IPkeyField & IcontrolName;
+type TSpecialFields = TSpecialDefault | TSpecialInput | TSpecialDropdown | TSpecialArray | TSpecialForm | TSpecialRichText | TSpecialAutocomplete | ISpecialCheckbox | ISpecialTextArea | ISpecialUpload | ISpecialLabel | ISpecialPkey | TSpecialDatepicker;
+interface IFormStructure {
+    [name: string]: Partial<TRawFields>;
+}
+
+declare class SpecialFormControl<T extends TRawFields> extends FormControl {
+    name: string;
+    placeholder: T['placeholder'];
+    label: T['label'];
+    tooltip: T['tooltip'];
+    icon: T['icon'];
+    elementId: T['elementId'];
+    styleClasses: T['styleClasses'];
+    length: T['length'];
+    required: T['required'];
+    hidden: T['hidden'];
+    readOnly: T['readOnly'];
+    settings: T['settings'];
+    type: T['type'];
+    errorMessages: T['errorMessages'];
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, length, placeholder, readOnly, required, tooltip, errorMessages, disabled, }: TSpecialFields);
+    setReadOnly(status?: boolean): void;
+    setDisabled(status?: boolean): void;
+    setHidden(status?: boolean): void;
+}
+declare class SpecialFormGroup extends FormGroup {
+    name: string;
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    length: number;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    settings: IFormSettings;
+    type: EControlTypes.form;
+    defaultValue: any;
+    errorMessages: {
+        [key: string]: string;
+    };
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, length, placeholder, readOnly, required, tooltip, disabled, }: TSpecialForm, controls: {
+        [key: string]: SpecialFormControl<any>;
+    });
+    getDirty(): void;
+    specialReset(value?: {}): void;
+    setReadOnly(status?: boolean): void;
+    setReadOnlyByFields(fieldsObject: {
+        [key: string]: boolean;
+    }): void;
+    setHiddenByFields(fields: {
+        [key: string]: boolean;
+    }): void;
+    setDisabled(status: boolean): void;
+    setDisabledByFields(fieldsObject: any): void;
+    /**
+     * donde value es el objeto semilla y detailForm es un arreglo de form key para dar un marco al formarray
+     */
+    setFormValue(value: any): void;
+    /**
+     * Método que retorna
+     */
+    getIdPkey(): SpecialFormControl<any> | undefined;
+}
+declare class SpecialFormArray extends FormArray implements IFieldBasicData {
+    name: string;
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    settings: IArraySettings;
+    type: EControlTypes;
+    defaultValue: any;
+    form: SpecialFormGroup;
+    private formCreation;
+    errorMessages: {
+        [key: string]: string;
+    };
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, placeholder, readOnly, required, tooltip, errorMessages, disabled, }: TSpecialArray, formCreation: () => SpecialFormGroup, controls: AbstractControl[]);
+    fillFormArray(data: any[]): void;
+    addItem(): void;
+    specialPush(index?: number): void;
+    specialInsert(index?: number): void;
+    specialEdit(index: number, newValue: Object): void;
+    /**
+     * Vuelve todos los controles del formArray de lectura o de sololectura
+     * @param status
+     */
+    setReadOnly(status: boolean): void;
+    /**
+     * Vuelve todos los controles del formArray habilitados o deshabilitados
+     * @param status
+     */
+    setDisabled(status: boolean): void;
+    /**
+     * Permite editar un control especifico.
+     * @param index
+     */
+    editControl(index: number): void;
+    getDirty(): void;
+    recursiveFillForm(form: FormGroup, data: any): FormGroup;
+}
+
+declare class SpecialAutocompleteComponent {
+    control: SpecialFormControl<IAutocompleteField>;
+    subs: Subscription;
+    constructor();
+    ngOnInit(): void;
+    get settings(): IAutocompleteSettings<any>;
+    init(): void;
+    configValue: (item: any) => any;
+    optionSelected(data: MatAutocompleteSelectedEvent): void;
+    iconClick(event: Event): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialAutocompleteComponent, "sp-autocomplete", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialInputComponent implements OnInit {
+    control: SpecialFormControl<IInputField>;
+    constructor();
+    ngOnInit(): void;
+    onEnterClick(): void;
+    onBlurAction(): void;
+    get settings(): IInputSettings;
+    iconClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialInputComponent, "sp-input", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialDropdownComponent {
+    control: SpecialFormControl<IDropdownField>;
+    get settings(): IDropdownSettings;
+    iconClick(event: Event): void;
+    optionSelected(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialDropdownComponent, "sp-dropdown", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialDatepickerComponent implements OnInit {
+    control: SpecialFormControl<IDatePickerField>;
+    constructor();
+    get settings(): IDatePickerSettings;
+    get startAt(): Date;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialDatepickerComponent, "sp-datepicker", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialMultipleAutocompleteComponent {
+    control: SpecialFormControl<IMultipleAutocompleteField>;
+    subs: Subscription;
+    internalControl: FormControl<any>;
+    constructor();
+    ngOnInit(): void;
+    get settings(): IMultipleAutocompleteSettings<any>;
+    init(): void;
+    optionSelected(data: MatAutocompleteSelectedEvent): void;
+    iconClick(event: Event): void;
+    remove(value: any[]): void;
+    configValue: (item: any) => any;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialMultipleAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialMultipleAutocompleteComponent, "sp-multiple-autocomplete", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialCheckboxComponent implements OnInit {
+    control: SpecialFormControl<ICheckboxField>;
+    get settings(): ICheckboxSettings;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialCheckboxComponent, "sp-checkbox", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialTextAreaComponent implements OnInit {
+    control: SpecialFormControl<ITextAreaField>;
+    onBlur: EventEmitter<any>;
+    onEnter: EventEmitter<any>;
+    constructor();
+    ngOnInit(): void;
+    get settings(): ITextAreaSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialTextAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialTextAreaComponent, "sp-text-area", never, { "control": { "alias": "control"; "required": false; }; }, { "onBlur": "onBlur"; "onEnter": "onEnter"; }, never, never, true, never>;
+}
+
+type TFieldControl<TField> = TField extends {
+    type: EControlTypes.form;
+} ? SpecialFormGroup : TField extends {
+    type: EControlTypes.array;
+} ? SpecialFormArray : SpecialFormControl<TField extends TRawFields ? TField : TRawFields>;
+type TFormControls<T extends IFormStructure> = {
+    [K in keyof T]: TFieldControl<NonNullable<T[K]>>;
+};
+type TFieldValue<TField> = TField extends IArrayField<infer TValue, infer TFields> ? TFields extends IFormStructure ? TFormValue<TFields>[] : TValue[] : TField extends IFormField<infer TValue, infer TFields> ? TFields extends IFormStructure ? TFormValue<TFields> : TValue : TField extends TRawFields ? TField['defaultValue'] : any;
+type TFormValue<T extends IFormStructure> = {
+    [K in keyof T]: TFieldValue<NonNullable<T[K]>>;
+};
+type TypedSpecialFormGroup<T extends IFormStructure> = SpecialFormGroup & {
+    controls: TFormControls<T>;
+    value: TFormValue<T>;
+    getRawValue: () => TFormValue<T>;
+};
+declare class SpecialFormBuilderService {
+    private readonly defectField;
+    private readonly inputDefectField;
+    private readonly formDefectField;
+    private readonly arrayDefectField;
+    control<T extends TRawFields>(field: Partial<T>): SpecialFormControl<T>;
+    group<T extends IFormStructure>(fields: T, parentField?: Partial<TSpecialForm>): TypedSpecialFormGroup<T>;
+    fieldDataToArray(fields: IFormStructure): TSpecialFields[];
+    private setDefectFieldOptions;
+    private formGenerator;
+    private getControlAndNameByType;
+    private setFormGroup;
+    private setFormArray;
+    private setFormControl;
+    private setRequiredValidator;
+    private setValidatorsArray;
+    private arrayLengthRequired;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialFormBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpecialFormBuilderService>;
+}
+
+declare class ErrorStateMatcherService implements ErrorStateMatcher {
+    isErrorState(control: FormControl): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateMatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorStateMatcherService>;
+}
+
+declare class SpecialUploadComponent {
+    readonly DEFAULT_ACCEPTED_TYPES = "image/png, .jpeg, .jpg, image/gif";
+    sfb: SpecialFormBuilderService;
+    set control(control: SpecialFormControl<IUploadField>);
+    get control(): SpecialFormControl<IUploadField>;
+    private internalControl;
+    realControl: SpecialFormControl<IUploadField>;
+    get settings(): IUploadSettings;
+    get elements(): any;
+    get multipleElements(): any;
+    get singleElement(): any[];
+    private initialConfig;
+    private minSizeConfig;
+    private maxSizeConfig;
+    private isFile;
+    private isNotFile;
+    private acceptConfig;
+    onSelectFile(input: File[] | File): void;
+    private updateRealControlInput;
+    private onSelectFileTrigger;
+    onRemove(input: File | string): void;
+    private removeFile;
+    private removeFileFromControl;
+    private removeElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialUploadComponent, "sp-upload", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialLabelComponent implements OnInit {
+    control: SpecialFormControl<ILabelField>;
+    constructor();
+    ngOnInit(): void;
+    get settings(): ILabelSettings;
+    onLink(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialLabelComponent, "sp-label", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialFormComponent implements OnInit {
+    form: SpecialFormGroup;
+    set control(form: SpecialFormGroup);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialFormComponent, "sp-form", never, { "form": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class SpecialArrayComponent implements OnInit {
+    formArray: any;
+    set control(formArray: any);
+    get withFormHeader(): any;
+    get settings(): any;
+    constructor();
+    ngOnInit(): void;
+    removeItem(index: number): void;
+    addItem(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialArrayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialArrayComponent, "sp-array", never, { "formArray": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class FormControlsRenderDirective {
+    private viewContainer;
+    private readonly componentsBuffer;
+    set controlSetter(control: SpecialFormControl<any>);
+    constructor(viewContainer: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormControlsRenderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormControlsRenderDirective, "[controlRender]", never, { "controlSetter": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FormControlsListPipe implements PipeTransform {
+    transform(controls: {
+        [key: string]: AbstractControl;
+    }): SpecialFormControl<any>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormControlsListPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormControlsListPipe, "controlsList", true>;
+}
+
+declare class SpecialRichtextComponent {
+    editor: Editor;
+    formControl: SpecialFormControl<IRichTextField>;
+    colorPresets: string[];
+    control: SpecialFormControl<IRichTextField>;
+    toolbar: Toolbar;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialRichtextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialRichtextComponent, "sp-input", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SpecialFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialFormModule, [typeof SpecialArrayComponent, typeof FormControlsRenderDirective, typeof SpecialFormComponent], [typeof i2.CommonModule, typeof FormControlsListPipe, typeof i4.MatButtonModule, typeof SpecialRichtextComponent, typeof SpecialDropdownComponent, typeof SpecialInputComponent, typeof SpecialAutocompleteComponent, typeof SpecialDatepickerComponent, typeof SpecialLabelComponent, typeof SpecialMultipleAutocompleteComponent, typeof SpecialCheckboxComponent, typeof SpecialTextAreaComponent, typeof SpecialUploadComponent], [typeof SpecialArrayComponent, typeof FormControlsRenderDirective, typeof SpecialFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialFormModule>;
+}
+
+declare abstract class ISpecialControl {
+    control: SpecialFormControl<any> | SpecialFormArray | SpecialFormGroup;
+}
+
+declare const currencyInputMask: any;
+
+declare const numberMask: (max?: number) => any;
+
+declare class ErrorMessagePipe implements PipeTransform {
+    transform(errorsObj: {
+        [key: string]: any;
+    }, errorMessages: {
+        [key: string]: any;
+    }, control?: FormControl): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorMessagePipe, "errorMessage", true>;
+}
+
+declare class TextByFunctionPipe implements PipeTransform {
+    transform(value: any, field: string | ((value: any) => string)): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextByFunctionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TextByFunctionPipe, "textByFunction", true>;
+}
+
+export { EControlTypes, ErrorMessagePipe, ErrorStateMatcherService, FormControlsListPipe, FormControlsRenderDirective, ISpecialControl, SpecialArrayComponent, SpecialAutocompleteComponent, SpecialCheckboxComponent, SpecialDatepickerComponent, SpecialDropdownComponent, SpecialFormArray, SpecialFormBuilderService, SpecialFormComponent, SpecialFormControl, SpecialFormGroup, SpecialFormModule, SpecialInputComponent, SpecialLabelComponent, SpecialMultipleAutocompleteComponent, SpecialRichtextComponent, SpecialTextAreaComponent, SpecialUploadComponent, TextByFunctionPipe, currencyInputMask, numberMask };
+export type { IArrayField, IArraySettings, IAutocompleteField, IAutocompleteSettings, ICheckboxField, ICheckboxSettings, IDatePickerField, IDatePickerSettings, IDefaultField, IDropdownField, IDropdownSettings, IFieldBasicData, IFieldData, IFormField, IFormSettings, IFormStructure, IInputField, IInputSettings, ILabelField, ILabelSettings, IMultipleAutocompleteField, IMultipleAutocompleteSettings, IPkeyField, IRichTextField, IRichTextSettings, ISpecialCheckbox, ISpecialLabel, ISpecialPkey, ISpecialTextArea, ISpecialUpload, ITextAreaField, ITextAreaSettings, IUploadField, IUploadSettings, TRawFields, TSpecialArray, TSpecialAutocomplete, TSpecialDatepicker, TSpecialDefault, TSpecialDropdown, TSpecialFields, TSpecialForm, TSpecialInput, TSpecialRichText };

package/lib/styles/final.scss

@@ -1,2 +1,2 @@
-@import "./styles-config.scss";
-@import "./tailwind-final.scss";
+@use "./styles-config.scss";
+@use "./tailwind-final.scss";

package/lib/styles/styles-config.scss

@@ -1,36 +1,36 @@
-@mixin dark-theme-config($back-color, $dark-text, $back-color-over) {
-  .mat-mdc-autocomplete-panel,
-  .mat-mdc-menu-content,
-  .mat-mdc-select-panel,
-  .mat-datepicker-content {
-    background: $back-color-over !important;
-  }
-
-  .mat-mdc-text-field-wrapper,
-  .special-upload__dropzone {
-    background: $back-color !important;
-  }
-
-  .special-upload__dropzone {
-    border-color: $dark-text !important;
-    color: $dark-text !important;
-  }
-
-  .NgxEditor__MenuBar {
-    background: $back-color !important;
-  }
-  .NgxEditor {
-    background: $back-color !important;
-    color: $dark-text !important;
-  }
-  .NgxEditor__MenuItem {
-    &:hover {
-      color: black !important;
-    }
-  }
-  .NgxEditor__Dropdown{
-    &:hover{
-      color: black !important;
-    }
-  }
-}
+@mixin dark-theme-config($back-color, $dark-text, $back-color-over) {
+  .mat-mdc-autocomplete-panel,
+  .mat-mdc-menu-content,
+  .mat-mdc-select-panel,
+  .mat-datepicker-content {
+    background: $back-color-over !important;
+  }
+
+  .mat-mdc-text-field-wrapper,
+  .special-upload__dropzone {
+    background: $back-color !important;
+  }
+
+  .special-upload__dropzone {
+    border-color: $dark-text !important;
+    color: $dark-text !important;
+  }
+
+  .NgxEditor__MenuBar {
+    background: $back-color !important;
+  }
+  .NgxEditor {
+    background: $back-color !important;
+    color: $dark-text !important;
+  }
+  .NgxEditor__MenuItem {
+    &:hover {
+      color: black !important;
+    }
+  }
+  .NgxEditor__Dropdown{
+    &:hover{
+      color: black !important;
+    }
+  }
+}