@stemy/ngx-dynamic-form 19.1.10 → 19.1.12

package/imports.d.ts

@@ -0,0 +1,12 @@
+import { DynamicFormControlMapFn } from "@ng-dynamic-forms/core";
+import { AsyncSubmitDirective } from "./directives/async-submit.directive";
+import { DynamicBaseFormComponent } from "./components/base/dynamic-base-form.component";
+import { DynamicBaseFormArrayComponent } from "./components/base/dynamic-base-form-array.component";
+import { DynamicBaseFormControlComponent } from "./components/base/dynamic-base-form-control.component";
+import { DynamicBaseFormControlContainerComponent } from "./components/base/dynamic-base-form-control-container.component";
+import { DynamicBaseFormGroupComponent } from "./components/base/dynamic-base-form-group.component";
+import { DynamicBaseSelectComponent } from "./components/base/dynamic-base-select.component";
+export declare const components: (typeof DynamicBaseFormComponent | typeof DynamicBaseFormArrayComponent | typeof DynamicBaseFormControlComponent | typeof DynamicBaseFormControlContainerComponent | typeof DynamicBaseFormGroupComponent | typeof DynamicBaseSelectComponent)[];
+export declare const directives: (typeof AsyncSubmitDirective)[];
+export declare const pipes: any[];
+export declare function defaultFormControlProvider(): DynamicFormControlMapFn;

package/ngx-dynamic-form/common-types.d.ts

@@ -18,7 +18,7 @@ export declare interface ModelType extends Function {
 }
 export type PromiseOrNot<T> = Promise<T> | T;
 export type FormControlSerializer = (model: DynamicFormValueControlModel<any>, control: AbstractControl) => Promise<any>;
-export type FormModelCustomizer = (property: IOpenApiSchemaProperty, schema: IOpenApiSchema, model: DynamicFormControlModel, config: DynamicFormControlModelConfig, injector: Injector) => PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
+export type FormModelCustomizer = (property: IOpenApiSchemaProperty, schema: IOpenApiSchema, model: DynamicFormControlModel, config: DynamicFormControlModelConfig, path: string, injector: Injector) => PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
 export interface ModelForSchemaOptions {
     labelPrefix?: string;
     customizer?: FormModelCustomizer;

package/ngx-dynamic-form/utils/customizer.d.ts

@@ -3,12 +3,12 @@ import { DynamicFormControlComponent, DynamicFormControlModel, DynamicFormContro
 import { CachedProvider, IOpenApiSchema, IOpenApiSchemaProperty } from "@stemy/ngx-utils";
 import { FormModelCustomizer, GetFormControlComponentType, PromiseOrNot } from "../common-types";
 export interface IFormComponentCustomizer {
-    acceptModel(model: DynamicFormControlModel): boolean;
+    acceptModel(model: DynamicFormControlModel, path: string): boolean;
     getFormComponent(model: DynamicFormControlModel): Type<DynamicFormControlComponent>;
 }
 export declare function getFormComponent(...providers: CachedProvider<IFormComponentCustomizer>[]): GetFormControlComponentType;
 export interface IFormModelCustomizer {
-    acceptModel(model: DynamicFormControlModel): boolean;
-    customizeModel(model: DynamicFormControlModel, config: DynamicFormControlModelConfig, property: IOpenApiSchemaProperty, schema: IOpenApiSchema): PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
+    acceptModel(model: DynamicFormControlModel, path: string): boolean;
+    customizeModel(model: DynamicFormControlModel, config: DynamicFormControlModelConfig, property: IOpenApiSchemaProperty, schema: IOpenApiSchema, path: string): PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
 }
 export declare function customizeFormModel(...providers: CachedProvider<IFormModelCustomizer>[]): FormModelCustomizer;

package/ngx-dynamic-form.imports.d.ts

@@ -0,0 +1,12 @@
+import { DynamicFormControlMapFn } from "@ng-dynamic-forms/core";
+import { AsyncSubmitDirective } from "./directives/async-submit.directive";
+import { DynamicBaseFormComponent } from "./components/base/dynamic-base-form.component";
+import { DynamicBaseFormArrayComponent } from "./components/base/dynamic-base-form-array.component";
+import { DynamicBaseFormControlComponent } from "./components/base/dynamic-base-form-control.component";
+import { DynamicBaseFormControlContainerComponent } from "./components/base/dynamic-base-form-control-container.component";
+import { DynamicBaseFormGroupComponent } from "./components/base/dynamic-base-form-group.component";
+import { DynamicBaseSelectComponent } from "./components/base/dynamic-base-select.component";
+export declare const components: (typeof DynamicBaseFormComponent | typeof DynamicBaseFormArrayComponent | typeof DynamicBaseFormControlComponent | typeof DynamicBaseFormControlContainerComponent | typeof DynamicBaseFormGroupComponent | typeof DynamicBaseSelectComponent)[];
+export declare const directives: (typeof AsyncSubmitDirective)[];
+export declare const pipes: any[];
+export declare function defaultFormControlProvider(): DynamicFormControlMapFn;

package/ngx-dynamic-form.module.d.ts

@@ -0,0 +1,21 @@
+import { EnvironmentProviders, ModuleWithProviders } from "@angular/core";
+import { IDynamicFormModuleConfig } from "./common-types";
+import * as i0 from "@angular/core";
+import * as i1 from "./components/base/dynamic-base-form.component";
+import * as i2 from "./components/base/dynamic-base-form-array.component";
+import * as i3 from "./components/base/dynamic-base-form-control.component";
+import * as i4 from "./components/base/dynamic-base-form-control-container.component";
+import * as i5 from "./components/base/dynamic-base-form-group.component";
+import * as i6 from "./components/base/dynamic-base-select.component";
+import * as i7 from "./directives/async-submit.directive";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+import * as i10 from "@stemy/ngx-utils";
+export declare class NgxDynamicFormModule {
+    private static getProviders;
+    static forRoot(config?: IDynamicFormModuleConfig): ModuleWithProviders<NgxDynamicFormModule>;
+    static provideForms(config?: IDynamicFormModuleConfig): EnvironmentProviders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDynamicFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicFormModule, [typeof i1.DynamicBaseFormComponent, typeof i2.DynamicBaseFormArrayComponent, typeof i3.DynamicBaseFormControlComponent, typeof i4.DynamicBaseFormControlContainerComponent, typeof i5.DynamicBaseFormGroupComponent, typeof i6.DynamicBaseSelectComponent, typeof i7.AsyncSubmitDirective], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i9.ReactiveFormsModule, typeof i10.NgxUtilsModule], [typeof i1.DynamicBaseFormComponent, typeof i2.DynamicBaseFormArrayComponent, typeof i3.DynamicBaseFormControlComponent, typeof i4.DynamicBaseFormControlContainerComponent, typeof i5.DynamicBaseFormGroupComponent, typeof i6.DynamicBaseSelectComponent, typeof i7.AsyncSubmitDirective, typeof i9.FormsModule, typeof i9.ReactiveFormsModule, typeof i10.NgxUtilsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDynamicFormModule>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stemy/ngx-dynamic-form",
-  "version": "19.1.10",
+  "version": "19.1.12",
   "license": "MIT",
   "public": true,
   "repository": "https://github.com/stemyke/ngx-dynamic-form.git",

package/services/dynamic-form.service.d.ts

@@ -0,0 +1,61 @@
+import { Injector } from "@angular/core";
+import { AbstractControl, AbstractControlOptions, FormArray, FormControl, FormGroup } from "@angular/forms";
+import { DynamicCheckboxModelConfig, DynamicDatePickerModelConfig, DynamicFileUploadModelConfig, DynamicFormComponentService, DynamicFormControlModel, DynamicFormModel, DynamicFormService as Base, DynamicFormValidationService, DynamicFormValueControlModelConfig, DynamicInputModelConfig, DynamicPathable, DynamicRadioGroupModelConfig, DynamicTextAreaModelConfig, DynamicValidatorsConfig } from "@ng-dynamic-forms/core";
+import { IApiService, ILanguageService, IOpenApiSchema, IOpenApiSchemaProperty, IOpenApiSchemas, OpenApiService } from "@stemy/ngx-utils";
+import { FormModelCustomizer, IDynamicForm, ModelForSchemaOptions, ModelForSchemaWrapOptions } from "../common-types";
+import { FormSelectSubject } from "../utils/form-select-subject";
+import { DynamicEditorModelConfig } from "../utils/dynamic-editor.model";
+import { DynamicFormArrayModel, DynamicFormArrayModelConfig } from "../utils/dynamic-form-array.model";
+import { DynamicFormFieldSet, DynamicFormGroupModel, DynamicFormGroupModelConfig } from "../utils/dynamic-form-group.model";
+import { DynamicFormOptionConfig, DynamicSelectModel, DynamicSelectModelConfig } from "../utils/dynamic-select.model";
+import { DynamicBaseFormComponent } from "../components/base/dynamic-base-form.component";
+import { AllValidationErrors } from "../utils/validation-errors";
+import * as i0 from "@angular/core";
+export declare class DynamicFormService extends Base {
+    readonly openApi: OpenApiService;
+    readonly injector: Injector;
+    get api(): IApiService;
+    get language(): ILanguageService;
+    protected schemas: IOpenApiSchemas;
+    constructor(cs: DynamicFormComponentService, vs: DynamicFormValidationService, openApi: OpenApiService, injector: Injector);
+    serializeForm(form: IDynamicForm, validate?: boolean): Promise<any>;
+    getFormModelForSchema(name: string, customizeOrOptions?: FormModelCustomizer | ModelForSchemaOptions): Promise<DynamicFormModel>;
+    getErrors(form: DynamicBaseFormComponent): Promise<AllValidationErrors[]>;
+    createFormGroup(formModel: DynamicFormModel, options?: AbstractControlOptions | null, parent?: DynamicPathable | null): import("@angular/forms").UntypedFormGroup;
+    patchGroup(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
+    patchForm(value: any, component: DynamicBaseFormComponent): void;
+    validateForm(form: IDynamicForm, showErrors?: boolean): Promise<any>;
+    serialize(formModel: DynamicFormModel, formGroup: FormGroup): Promise<any>;
+    showErrors(form: IDynamicForm): void;
+    notifyChanges(formModel: DynamicFormModel, formGroup: FormGroup, root: DynamicFormModel): void;
+    protected patchValues(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
+    protected updateSelectOptions(formControlModel: DynamicFormControlModel, formControl: FormControl, root: DynamicFormModel): void;
+    protected showErrorsForGroup(formGroup: FormGroup): void;
+    protected showErrorsForControls(controls: AbstractControl[]): void;
+    protected convertToDate(value: any): Date;
+    getFormGroupModelForSchema(name: string, customizeOrOptions?: FormModelCustomizer | ModelForSchemaOptions): Promise<DynamicFormGroupModel>;
+    protected getFormModelForSchemaDef(schema: IOpenApiSchema, fieldSets: DynamicFormFieldSet<string>[], options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormModel>;
+    protected checkIsEditorProperty(property: IOpenApiSchemaProperty): boolean;
+    protected getFormControlModels(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormControlModel[]>;
+    findModelByPath(parent: DynamicPathable | DynamicFormModel, path: string[]): DynamicPathable;
+    getFormControlConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicFormValueControlModelConfig<any>;
+    getFormArrayConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormArrayModelConfig>;
+    getFormGroupConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormGroupModelConfig>;
+    getFormInputConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicInputModelConfig;
+    getFormEditorConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicEditorModelConfig;
+    getFormTextareaConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicTextAreaModelConfig;
+    getFormDatepickerConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicDatePickerModelConfig;
+    getFormSelectOptions(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): FormSelectSubject<DynamicFormOptionConfig<any>[]>;
+    getFormRadioConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicRadioGroupModelConfig<any>;
+    getFormSelectConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicSelectModelConfig<any>;
+    getFormUploadConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicFileUploadModelConfig;
+    getFormCheckboxConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicCheckboxModelConfig;
+    cloneFormArrayGroup(index: number, formArray: FormArray, formArrayModel: DynamicFormArrayModel): void;
+    protected replaceOptionsEndpoint(endpoint: string, key: string, value: any): string;
+    protected fixSelectOptions(model: DynamicSelectModel<any>, control: FormControl, options: DynamicFormOptionConfig<any>[]): Promise<DynamicFormOptionConfig<any>[]>;
+    protected getValidators(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicValidatorsConfig;
+    protected addPropertyValidators(validators: DynamicValidatorsConfig, property: IOpenApiSchemaProperty): void;
+    protected addItemsValidators(validators: DynamicValidatorsConfig, items: IOpenApiSchemaProperty): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormService>;
+}

package/src/ngx-dynamic-form/nebular/imports.d.ts

@@ -0,0 +1,4 @@
+import { Type } from "@angular/core";
+export declare const components: Type<any>[];
+export declare const directives: any[];
+export declare const pipes: any[];

package/src/ngx-dynamic-form/nebular/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@stemy/ngx-dynamic-form/src/ngx-dynamic-form/nebular" />
+export * from './public_api';

package/src/ngx-dynamic-form/nebular/ngx-dynamic-form.nebular.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@stemy/ngx-dynamic-form";
+export declare class NgxDynamicFormNebularModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDynamicFormNebularModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicFormNebularModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.NgxDynamicFormModule], [typeof i3.NgxDynamicFormModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDynamicFormNebularModule>;
+}

package/src/ngx-dynamic-form/nebular/public_api.d.ts

@@ -0,0 +1 @@
+export { NgxDynamicFormNebularModule } from "./ngx-dynamic-form.nebular.module";

package/ui-nebular/imports.d.ts

@@ -0,0 +1,4 @@
+import { Type } from "@angular/core";
+export declare const components: Type<any>[];
+export declare const directives: any[];
+export declare const pipes: any[];

package/ui-nebular/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@stemy/ngx-dynamic-form/ui-nebular" />
+export * from './public_api';

package/ui-nebular/ngx-dynamic-form.nebular.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@stemy/ngx-dynamic-form";
+export declare class NgxDynamicFormNebularModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDynamicFormNebularModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicFormNebularModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.NgxDynamicFormModule], [typeof i3.NgxDynamicFormModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDynamicFormNebularModule>;
+}

package/ui-nebular/public_api.d.ts

@@ -0,0 +1 @@
+export { NgxDynamicFormNebularModule } from "./ngx-dynamic-form.nebular.module";

package/utils/creators.d.ts

@@ -0,0 +1,18 @@
+import { DynamicCheckboxModel, DynamicCheckboxModelConfig, DynamicDatePickerModel, DynamicFileUploadModel, DynamicFileUploadModelConfig, DynamicFormControlLayout, DynamicFormValueControlModelConfig, DynamicInputModel, DynamicInputModelConfig, DynamicTextAreaModel, DynamicTextAreaModelConfig } from "@ng-dynamic-forms/core";
+import { DynamicEditorModel, DynamicEditorModelConfig } from "./dynamic-editor.model";
+import { DynamicFormArrayModel, DynamicFormArrayModelConfig } from "./dynamic-form-array.model";
+import { DynamicFormGroupModel, DynamicFormGroupModelConfig } from "./dynamic-form-group.model";
+import { DynamicSelectModel, DynamicSelectModelConfig } from "./dynamic-select.model";
+export type ValueModelConfig = DynamicFormValueControlModelConfig<any>;
+export type OmitId<T extends ValueModelConfig> = Omit<T, "id">;
+export type AddId<T extends OmitId<ValueModelConfig>> = T extends OmitId<(infer U)> ? U : never;
+export declare function createFormConfig<T extends ValueModelConfig, U extends OmitId<T>>(id: string, config?: U): AddId<U>;
+export declare function createFormCheckbox(id: string, config: OmitId<DynamicCheckboxModelConfig>, layout?: DynamicFormControlLayout): DynamicCheckboxModel;
+export declare function createFormDate(id: string, config: OmitId<DynamicDatePickerModel>, layout?: DynamicFormControlLayout): DynamicDatePickerModel;
+export declare function createFormEditor(id: string, config: OmitId<DynamicEditorModelConfig>, layout?: DynamicFormControlLayout): DynamicEditorModel;
+export declare function createFormArray(id: string, config: OmitId<DynamicFormArrayModelConfig>, layout?: DynamicFormControlLayout): DynamicFormArrayModel;
+export declare function createFormGroup(id: string, config: OmitId<DynamicFormGroupModelConfig>, layout?: DynamicFormControlLayout): DynamicFormGroupModel;
+export declare function createFormInput(id: string, config: OmitId<DynamicInputModelConfig>, type?: string, layout?: DynamicFormControlLayout): DynamicInputModel;
+export declare function createFormSelect<T = any>(id: string, config: OmitId<DynamicSelectModelConfig<T>>, layout?: DynamicFormControlLayout): DynamicSelectModel<T>;
+export declare function createFormTextarea(id: string, config: OmitId<DynamicTextAreaModelConfig>, layout?: DynamicFormControlLayout): DynamicTextAreaModel;
+export declare function createFormFile(id: string, config: OmitId<DynamicFileUploadModelConfig>, layout?: DynamicFormControlLayout): DynamicFileUploadModel;

package/utils/customizer.d.ts

@@ -0,0 +1,14 @@
+import { Type } from "@angular/core";
+import { DynamicFormControlComponent, DynamicFormControlModel, DynamicFormControlModelConfig } from "@ng-dynamic-forms/core";
+import { CachedProvider, IOpenApiSchema, IOpenApiSchemaProperty } from "@stemy/ngx-utils";
+import { FormModelCustomizer, GetFormControlComponentType, PromiseOrNot } from "../common-types";
+export interface IFormComponentCustomizer {
+    acceptModel(model: DynamicFormControlModel): boolean;
+    getFormComponent(model: DynamicFormControlModel): Type<DynamicFormControlComponent>;
+}
+export declare function getFormComponent(...providers: CachedProvider<IFormComponentCustomizer>[]): GetFormControlComponentType;
+export interface IFormModelCustomizer {
+    acceptModel(model: DynamicFormControlModel): boolean;
+    customizeModel(model: DynamicFormControlModel, config: DynamicFormControlModelConfig, property: IOpenApiSchemaProperty, schema: IOpenApiSchema): PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
+}
+export declare function customizeFormModel(...providers: CachedProvider<IFormModelCustomizer>[]): FormModelCustomizer;

package/utils/dynamic-editor.model.d.ts

@@ -0,0 +1,11 @@
+import { DynamicFormControlLayout, DynamicInputControlModel, DynamicInputControlModelConfig } from "@ng-dynamic-forms/core";
+export interface DynamicEditorModelConfig extends DynamicInputControlModelConfig<string | Object> {
+    inputType: string;
+    convertObject?: boolean;
+}
+export declare class DynamicEditorModel extends DynamicInputControlModel<string | Object> {
+    readonly type: string;
+    readonly inputType: string;
+    readonly convertObject: boolean;
+    constructor(config: DynamicEditorModelConfig, layout?: DynamicFormControlLayout);
+}

package/utils/dynamic-form-array.model.d.ts

@@ -0,0 +1,69 @@
+import { Injector } from "@angular/core";
+import { FormArray } from "@angular/forms";
+import { BehaviorSubject } from "rxjs";
+import { DynamicFormArrayGroupModel as GroupBase, DynamicFormArrayModel as Base, DynamicFormArrayModelConfig as ConfigBase, DynamicFormControlLayout, DynamicFormModel } from "@ng-dynamic-forms/core";
+import { ITimer } from "@stemy/ngx-utils";
+export type SaveTabFunc = (index: number, model: DynamicFormArrayGroupModel, arrayModel: DynamicFormArrayModel, injector: Injector) => void;
+export type RestoreTabFunc = (arrayModel: DynamicFormArrayModel, injector: Injector) => number;
+export type TabLabelFunc = (index: number, model: DynamicFormArrayGroupModel, arrayModel: DynamicFormArrayModel, array: FormArray, injector: Injector) => string;
+export declare class DynamicFormArrayGroupModel extends GroupBase {
+    readonly context: DynamicFormArrayModel;
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    protected isHidden: boolean;
+    constructor(context: DynamicFormArrayModel, group: DynamicFormModel, index?: number);
+}
+export interface DynamicFormArrayModelConfig extends ConfigBase {
+    groups?: DynamicFormArrayGroupModel[] | null;
+    sortable?: boolean;
+    useTabs?: boolean;
+    saveTab?: SaveTabFunc;
+    restoreTab?: RestoreTabFunc;
+    getTabLabel?: TabLabelFunc;
+    additional?: {
+        [key: string]: any;
+    };
+    addItem?: boolean;
+    insertItem?: boolean;
+    cloneItem?: boolean;
+    moveItem?: boolean;
+    removeItem?: boolean;
+    clearItems?: boolean;
+}
+export declare class DynamicFormArrayModel extends Base {
+    protected config: DynamicFormArrayModelConfig;
+    readonly filteredGroups: BehaviorSubject<ReadonlyArray<DynamicFormArrayGroupModel>>;
+    readonly sortable: boolean;
+    readonly useTabs: boolean;
+    readonly saveTab: SaveTabFunc;
+    readonly restoreTab: RestoreTabFunc;
+    readonly getTabLabel: TabLabelFunc;
+    readonly additional: {
+        [key: string]: any;
+    };
+    groups: DynamicFormArrayGroupModel[];
+    tabIndex: number;
+    protected _sortBy: string;
+    protected _sortDescending: boolean;
+    protected _formArray: FormArray;
+    protected _filteredGroups: ReadonlyArray<DynamicFormArrayGroupModel>;
+    protected _filterTimer: ITimer;
+    get addItem(): boolean;
+    get insertItem(): boolean;
+    get cloneItem(): boolean;
+    get moveItem(): boolean;
+    get removeItem(): boolean;
+    get clearItems(): boolean;
+    get sortBy(): string;
+    set sortBy(value: string);
+    get sortDescending(): boolean;
+    get sortOrder(): string;
+    constructor(config: DynamicFormArrayModelConfig, layout?: DynamicFormControlLayout);
+    initialize(array?: FormArray): void;
+    filterGroups(): void;
+    getFiltered(index: number): DynamicFormArrayGroupModel;
+    insertGroup(index: number): DynamicFormArrayGroupModel;
+    moveGroup(index: number, step: number): void;
+    removeGroup(index: number): void;
+    protected compareModels(a: DynamicFormArrayGroupModel, b: DynamicFormArrayGroupModel): number;
+}

package/utils/dynamic-form-group.model.d.ts

@@ -0,0 +1,14 @@
+import { DynamicFormControlLayout, DynamicFormControlModel, DynamicFormGroupModel as Base, DynamicFormGroupModelConfig as BaseConfig } from "@ng-dynamic-forms/core";
+export interface DynamicFormFieldSet<T> {
+    id: string;
+    legend: string;
+    fields: T[];
+}
+export type DynamicFormFieldSets<T> = ReadonlyArray<DynamicFormFieldSet<T>>;
+export interface DynamicFormGroupModelConfig extends BaseConfig {
+    fieldSets?: DynamicFormFieldSets<string>;
+}
+export declare class DynamicFormGroupModel extends Base {
+    readonly groups: DynamicFormFieldSets<DynamicFormControlModel>;
+    constructor(config: DynamicFormGroupModelConfig, layout?: DynamicFormControlLayout);
+}

package/utils/dynamic-select.model.d.ts

@@ -0,0 +1,39 @@
+import { Injector } from "@angular/core";
+import { FormControl } from "@angular/forms";
+import { Observable } from "rxjs";
+import { DynamicFormControlLayout, DynamicFormOption as BaseOption, DynamicFormOptionConfig as BaseOptionConfig, DynamicSelectModel as Base, DynamicSelectModelConfig as BaseConfig } from "@ng-dynamic-forms/core";
+export interface DynamicFormOptionConfig<T> extends BaseOptionConfig<T> {
+    classes?: string;
+    [key: string]: any;
+}
+export declare class DynamicFormOption<T> extends BaseOption<T> {
+    readonly classes: string;
+    readonly props: any;
+    constructor(config: DynamicFormOptionConfig<T>);
+}
+export interface DynamicFormOptionGroup<T> {
+    group: string;
+    options: ReadonlyArray<DynamicFormOption<T>>;
+}
+export type OptionClassesFunc<T> = (option: DynamicFormOptionConfig<T>, model: DynamicSelectModel<T>, control: FormControl, injector: Injector) => string;
+export interface DynamicSelectModelConfig<T> extends BaseConfig<T> {
+    groupBy?: string;
+    inline?: boolean;
+    options?: DynamicFormOptionConfig<T>[] | Observable<DynamicFormOptionConfig<T>[]>;
+    getClasses?: OptionClassesFunc<T>;
+    allowEmpty?: boolean;
+}
+export declare class DynamicSelectModel<T> extends Base<T> {
+    readonly groupBy: string;
+    readonly inline: boolean;
+    readonly getClasses: OptionClassesFunc<T>;
+    readonly allowEmpty: boolean;
+    options$: Observable<DynamicFormOption<T>[]>;
+    protected mOptions: DynamicFormOption<T>[];
+    constructor(config: DynamicSelectModelConfig<T>, layout?: DynamicFormControlLayout);
+    set options(options: any);
+    get options(): ReadonlyArray<DynamicFormOption<T>>;
+    insert(index: number, optionConfig: DynamicFormOptionConfig<T>): DynamicFormOption<T>;
+    remove(...indices: number[]): void;
+    protected updateOptions(): void;
+}

package/utils/form-select-subject.d.ts

@@ -0,0 +1,6 @@
+import { AbstractControl } from "@angular/forms";
+import { DynamicFormOptionConfig, DynamicSelectModel } from "./dynamic-select.model";
+import { FormSubject } from "./form-subject";
+export declare class FormSelectSubject<T extends DynamicFormOptionConfig<any>[]> extends FormSubject<DynamicSelectModel<any>, T> {
+    protected handleNotifiedValue(controlModel: DynamicSelectModel<any>, control: AbstractControl, val: Promise<T>): void;
+}

package/utils/form-subject.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from "rxjs";
+import { FormControl } from "@angular/forms";
+import { DynamicFormControlModel, DynamicFormModel } from "@ng-dynamic-forms/core";
+export type NotifyCallback<M extends DynamicFormControlModel> = (controlModel: M, control: FormControl, root: DynamicFormModel, indexes: any) => any | Promise<any>;
+export declare class FormSubject<M extends DynamicFormControlModel, T> extends Subject<T> {
+    private readonly notifyCallback;
+    constructor(notifyCallback: NotifyCallback<M>);
+    protected handleNotifiedValue(controlModel: M, control: FormControl, val: Promise<T>): void;
+    notify(controlModel: M, control: FormControl, root: DynamicFormModel): void;
+}

package/utils/misc.d.ts

@@ -0,0 +1,11 @@
+import { DynamicFormModel, DynamicPathable } from "@ng-dynamic-forms/core";
+import { IOpenApiSchemaProperty } from "@stemy/ngx-utils";
+export declare function isStringWithVal(val: any): boolean;
+export declare function findRefs(property: IOpenApiSchemaProperty): string[];
+export declare function replaceSpecialChars(str: string, to?: string): string;
+export declare function mergeFormModels(formModels: DynamicFormModel[]): DynamicFormModel;
+export declare function collectPathAble<T extends DynamicPathable>(start: T, getter: (cur: T & DynamicPathable) => string): string[];
+export declare function getDynamicPath(start: DynamicPathable): string;
+export declare const MIN_INPUT_NUM = -999999999;
+export declare const MAX_INPUT_NUM = 999999999;
+export declare const EDITOR_FORMATS: string[];

package/utils/validation-errors.d.ts

@@ -0,0 +1,11 @@
+import { AbstractControl } from "@angular/forms";
+export interface AllValidationErrors {
+    control: AbstractControl;
+    path: string;
+    errorKey: string;
+    errorValue: any;
+}
+export interface FormGroupControls {
+    [key: string]: AbstractControl;
+}
+export declare function getFormValidationErrors(controls: FormGroupControls, parentPath?: string): AllValidationErrors[];

package/utils/validators.d.ts

@@ -0,0 +1,8 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from "@angular/forms";
+export declare function validateJSON(control: AbstractControl): ValidationErrors | null;
+export declare function validateRequiredTranslation(control: AbstractControl): ValidationErrors | null;
+export declare function validatePhone(control: AbstractControl): ValidationErrors | null;
+export declare function validateItemsMinLength(minLength: number): ValidatorFn;
+export declare function validateItemsMaxLength(maxLength: number): ValidatorFn;
+export declare function validateItemsMinValue(min: number): ValidatorFn;
+export declare function validateItemsMaxValue(max: number): ValidatorFn;