@mediusinc/mng-commons 3.6.0 → 3.7.0-rc.0

package/lib/data-providers/tableview.data-provider.d.ts

@@ -1,33 +1,45 @@
-import { Type } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import { MediusQueryParam, MediusQueryResult } from '../api/models';
-import { ClassType, IdType } from '../types';
-import { EditorDataProvider, IEditorDataProvider } from './editor.data-provider';
-import { ITableDataProvider } from './table.data-provider';
-export interface ITableviewDataProvider<T, S> extends IEditorDataProvider<T, S> {
+import { MediusQueryParam } from '../api/models';
+import { ClassOptType, ClassType, ServiceClassOptType, ServiceClassType } from '../types';
+import { DataProviderInst } from './base.data-provider';
+import { EditorDataProviderCreateFnType, EditorDataProviderDeleteFnType, EditorDataProviderFetchFnType, EditorDataProviderInst, EditorDataProviderUpdateFnType, IEditorDataProvider } from './editor.data-provider';
+import { ITableDataProvider, TableDataProviderGetAllEagerFnType, TableDataProviderGetAllFnType, TableDataProviderInst } from './table.data-provider';
+export type ITableviewDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IEditorDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProvider<Model, Service, ModelClass, ServiceClass>;
+export declare class TableviewDataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableviewDataProvider<Model, Service, ModelClass, ServiceClass> {
+    protected readonly editorDataProvider: EditorDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+    protected readonly tableDataProvider: TableDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+    protected constructor(type: ModelClass, serviceType: ServiceClass);
     get isLazy(): boolean;
-    getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>;
-    getAllReload(queryParam?: MediusQueryParam): void;
-    getAllReload$: Observable<MediusQueryParam | undefined>;
+    get getAllReload$(): import("rxjs").Observable<MediusQueryParam | undefined>;
+    get getAll(): TableDataProviderGetAllFnType<Model, Service, import("../types").ItemOrObservable<import("../api/models").MediusQueryResult<Model>>>;
+    get fetch(): EditorDataProviderFetchFnType<Model, Service, import("../types").IdType, import("../types").ItemOrObservable<Model>>;
+    get create(): EditorDataProviderCreateFnType<Model, Service, Model | undefined, import("../types").ItemOrObservable<Model>> | undefined;
+    get update(): EditorDataProviderUpdateFnType<Model, Service, import("../types").IdType, Model | undefined, import("../types").ItemOrObservable<Model>> | undefined;
+    get delete(): EditorDataProviderDeleteFnType<Model, Service, import("../types").IdType, Model | undefined, import("../types").ItemOrObservable<Model | null>> | undefined;
+    getAllReload(queryParam?: MediusQueryParam | undefined): void;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service>): this;
+    withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<Model, Service>): this;
+    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
+    withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<Model, Service>): this;
+    withDelete(fn?: EditorDataProviderDeleteFnType<Model, Service>): this;
 }
-export declare class TableviewDataProvider<T, S> extends EditorDataProvider<T, S> implements ITableviewDataProvider<T, S>, ITableDataProvider<T, S>, IEditorDataProvider<T, S> {
-    protected _isLazy: boolean;
-    protected _getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>;
-    protected _getAllReloadSubject: Subject<MediusQueryParam | undefined>;
-    constructor(modelType: ClassType<T>, serviceType?: Type<S>);
-    get isLazy(): boolean;
-    get getAll(): (queryParam: MediusQueryParam, service?: S | undefined, locale?: string | undefined) => Observable<MediusQueryResult<T>>;
-    get getAllReload$(): Observable<MediusQueryParam | undefined>;
-    withGetAll(getAll: (queryParam: MediusQueryParam, service?: S, locale?: string) => Observable<MediusQueryResult<T>>): this;
-    /**
-     * Use this method to use inline load without lazy loading features on table and use inline pagination, filtering and sorting.
-     * @param getAll
-     */
-    withGetAllEagerly(getAll: (service?: S, locale?: string) => Observable<Array<T>>): this;
-    getAllReload(queryParam?: MediusQueryParam): void;
+export declare class TableviewDataProvider extends TableviewDataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): TableviewDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): TableviewDataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): TableviewDataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableviewDataProviderInst<Model, Service, ModelClass, ServiceClass>;
+}
+export declare class DynamicTableviewDataProviderInst<Service = any, ServiceClass = ServiceClassOptType<Service>> extends TableviewDataProviderInst<any, Service, undefined, ServiceClass> {
+    protected constructor(serviceType: ServiceClass);
 }
-export declare class DynamicTableviewDataProvider extends TableviewDataProvider<any, any> implements ITableviewDataProvider<any, any>, ITableDataProvider<any, any> {
-    protected _getAll: (queryParam: MediusQueryParam, locale?: string) => Observable<MediusQueryResult<any>>;
-    protected _fetch: (id: IdType, locale?: string) => Observable<any>;
-    constructor();
+export declare class DynamicTableviewDataProvider extends DynamicTableviewDataProviderInst {
+    protected constructor();
+    static create(): DynamicTableviewDataProviderInst<undefined>;
+    static fromService<Service>(serviceType: ServiceClassType<Service>): DynamicTableviewDataProviderInst<Service, ServiceClassType<Service>>;
 }

package/lib/descriptors/action/action-confirmation.descriptor.d.ts

@@ -1,7 +1,7 @@
 import { Confirmation } from 'primeng/api';
 import { ActionContext } from '../../components/action/models';
 import { ActionButtonDescriptor } from './action-button.descriptor';
-export declare class ActionConfirmationDialogDescriptor<T> {
+export declare class ActionConfirmationDescriptor<Model> {
     private _icon?;
     private _title?;
     private _message?;
@@ -23,13 +23,13 @@ export declare class ActionConfirmationDialogDescriptor<T> {
      */
     withCloseOnEscape(closeOnEscape: boolean): this;
     withClosable(closable: boolean): this;
-    withRunConfirmationConfigMapFn(runConfirmationConfigMapFn?: ConfigurationConfigMapFn<T>): this;
+    withRunConfirmationConfigMapFn(runConfirmationConfigMapFn?: ConfigurationConfigMapFn<Model>): this;
     get icon(): string | undefined;
     get title(): string | null | undefined;
     get message(): string | null | undefined;
     get closeOnEscape(): boolean;
     get closable(): boolean;
-    get runConfirmationConfigMapFn(): ConfigurationConfigMapFn<T> | undefined;
+    get runConfirmationConfigMapFn(): ConfigurationConfigMapFn<Model> | undefined;
     get acceptButton(): ActionButtonDescriptor;
     get rejectButton(): ActionButtonDescriptor | undefined;
 }

package/lib/descriptors/action/action-editor.descriptor.d.ts

@@ -0,0 +1,115 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ActionContext } from '../../components/action/models';
+import { IEditorDataProvider } from '../../data-providers';
+import { StyleSizeEnum } from '../../styles/models';
+import { ServiceClassType } from '../../types';
+import { EditorDescriptorInst } from '../editor';
+import { ModelDescriptor } from '../model';
+import { ActionEditorSubmitTypeEnum } from '../types';
+import { ActionDescriptorCreateOptsParentType, ActionDescriptorInst } from './action.descriptor';
+export type ActionEditorDescriptorConstructorOptsType<Model, Service> = ActionDescriptorCreateOptsParentType & ActionEditorDescriptorCreateOptsProviderType<Model, Service> & {
+    model?: ModelDescriptor<Model>;
+};
+export type ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: IEditorDataProvider<Model, Service>;
+};
+export type ActionEditorProviderType<Model, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service>;
+export declare const actionEditorGetProviderCfgObj: <Model, Service>(serviceOrDataProvider?: ActionEditorProviderType<Model, Service> | undefined) => ActionEditorDescriptorCreateOptsProviderType<Model, Service>;
+export declare class ActionEditorDescriptorInst<Model, Service = any> extends ActionDescriptorInst<Model, Service> {
+    private readonly _editorDescriptor;
+    protected readonly _dataProvider?: IEditorDataProvider<Model, any>;
+    protected _editorActions: ActionDescriptorInst<Model>[];
+    protected _editorTitle?: string | null;
+    protected _editorTitleParams?: any;
+    protected _hasFetchNotificationSuccess: boolean;
+    protected _fetchNotificationSuccessTitle?: string;
+    protected _fetchNotificationSuccessMessage?: string;
+    protected _dialogSize: StyleSizeEnum;
+    protected _dialogClassName?: string;
+    protected _fetchFunction?: (ctx: ActionContext<Model, any>) => Observable<Model>;
+    protected _submitFunction?: (ctx: ActionContext<Model, any>) => Observable<Model>;
+    protected _editorComponent?: Type<any>;
+    protected _resubmitEnabled?: boolean;
+    protected _resubmitRefetch: boolean;
+    protected _unsavedChangesConfirmation: boolean;
+    constructor(editorDescriptor: EditorDescriptorInst<Model>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Model, Service>);
+    get editorTitle(): string | null | undefined;
+    get editorTitleParams(): any;
+    get editorDescriptor(): EditorDescriptorInst<Model>;
+    get dialogSize(): StyleSizeEnum;
+    get dialogClassName(): string | undefined;
+    get hasFetchNotificationSuccess(): boolean;
+    get fetchNotificationSuccessTitle(): string | undefined;
+    get fetchNotificationSuccessMessage(): string | undefined;
+    get dataProvider(): IEditorDataProvider<Model, any> | undefined;
+    get runFunction(): (ctx: ActionContext<Model, unknown>) => Observable<Model>;
+    get fetchFunction(): ((ctx: ActionContext<Model, any>) => Observable<Model>) | undefined;
+    get submitFunction(): ((ctx: ActionContext<Model, any>) => Observable<Model>) | undefined;
+    get editorActions(): ActionDescriptorInst<Model, any>[];
+    get editorComponent(): Type<any> | undefined;
+    get resubmitEnabled(): boolean | undefined;
+    get resubmitRefetch(): boolean;
+    get unsavedChangesConfirmation(): boolean;
+    withEditorTitle(title: string | null, params?: any): this;
+    withDialogSize(size?: StyleSizeEnum): this;
+    withDialogClassName(className: string): this;
+    withRunFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
+    withFetchFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
+    withSubmitFunction(fn: (ctx: ActionContext<Model, Service>) => Observable<Model>): this;
+    withFetchNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
+    withEditorAction(action: ActionDescriptorInst<Model>): this;
+    withEditorActions(actions: ActionDescriptorInst<Model>[]): this;
+    withEditorComponent(editorComponent: Type<any>): this;
+    withResubmit(enabled?: boolean, refetch?: boolean): this;
+    withUnsavedChangesConfirmation(unsavedChangesConfirmation?: boolean): this;
+}
+export declare class ActionEditorDescriptor {
+    static create<Model>(editor: EditorDescriptorInst<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionEditorDescriptorInst<Model, undefined>;
+    static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionEditorDescriptorInst<Model, Service>;
+}
+export declare class ActionEditorSubmitDescriptorInst<Model> extends ActionDescriptorInst<Model> {
+    private readonly _editorAction;
+    private readonly _submitType;
+    constructor(editorAction: ActionEditorDescriptorInst<Model>, submitType?: ActionEditorSubmitTypeEnum);
+    get submitType(): ActionEditorSubmitTypeEnum;
+}
+export declare class ActionEditorSubmitDescriptor {
+    /**
+     * creates primary action with primary button style
+     * @param editorAction
+     * @param submitType
+     */
+    static forPrimary<Model>(editorAction: ActionEditorDescriptorInst<Model>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptorInst<Model>;
+    /**
+     * creates secondary button with text button style
+     * @param editorAction
+     * @param submitType
+     */
+    static forSecondary<Model>(editorAction: ActionEditorDescriptorInst<Model>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptorInst<Model>;
+}
+export declare class ActionEditorDetailsDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {
+    static readonly ACTION_NAME = "details";
+    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>);
+}
+export declare class ActionEditorDetailsDescriptor {
+    static create<Model>(editor: EditorDescriptorInst<Model>): ActionEditorDetailsDescriptorInst<Model, undefined>;
+    static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>): ActionEditorDetailsDescriptorInst<Model, Service>;
+}
+export declare class ActionEditorAddDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {
+    static readonly ACTION_NAME = "add";
+    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>);
+}
+export declare class ActionEditorAddDescriptor {
+    static create<Model>(editor: EditorDescriptorInst<Model>): ActionEditorAddDescriptorInst<Model, undefined>;
+    static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>): ActionEditorAddDescriptorInst<Model, Service>;
+}
+export declare class ActionEditorEditDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {
+    static readonly ACTION_NAME = "edit";
+    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>);
+}
+export declare class ActionEditorEditDescriptor {
+    static create<Model>(editor: EditorDescriptorInst<Model>): ActionEditorEditDescriptorInst<Model, undefined>;
+    static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>): ActionEditorEditDescriptorInst<Model, Service>;
+}

package/lib/descriptors/action/action-link.descriptor.d.ts

@@ -0,0 +1,34 @@
+import { Params, QueryParamsHandling } from '@angular/router';
+import { ClassType } from '../../types';
+import { ModelDescriptor } from '../model';
+import { ActionDescriptorConstructorOptsType, ActionDescriptorCreateFromClassOpts, ActionDescriptorCreateOptsParentType, ActionDescriptorInst } from './action.descriptor';
+export type ActionLinkDescriptorConstructorOpts<Model> = Omit<ActionDescriptorConstructorOptsType<Model, undefined>, 'serviceType' | 'dataProvider'>;
+export declare class ActionLinkDescriptorInst<Model> extends ActionDescriptorInst<Model, undefined> {
+    private _url;
+    private _pathSegments;
+    private _queryParams?;
+    private _queryParamsHandling?;
+    private _replaceUrl;
+    private _target;
+    private _isStyleLink;
+    constructor(actionName?: string, cfg?: ActionLinkDescriptorConstructorOpts<Model>);
+    get url(): string;
+    get pathSegments(): string[];
+    get queryParams(): Params | undefined;
+    get queryParamsHandling(): QueryParamsHandling | undefined;
+    get replaceUrl(): boolean;
+    get target(): string;
+    get isStyleLink(): boolean;
+    withHref(url: string): this;
+    withRouterLink(...pathSegments: string[]): this;
+    withQueryParams(queryParams: Params, queryParamsHandling?: QueryParamsHandling): this;
+    withReplaceUrl(replaceUrl?: boolean): this;
+    withTarget(target?: '_self' | '_blank'): this;
+    withStyleLink(isStyleLink: boolean): this;
+}
+export declare class ActionLinkDescriptor {
+    static create<Model = any>(actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionLinkDescriptorInst<Model>;
+    static fromModel<Model>(model: ModelDescriptor<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionLinkDescriptorInst<Model>;
+    static fromClass<Model>(type: ClassType<Model>, actionName: string, cfg?: ActionDescriptorCreateFromClassOpts<Model>): ActionLinkDescriptorInst<Model>;
+    static fromAction<Model>(action: ActionDescriptorInst<Model>): ActionLinkDescriptorInst<Model>;
+}

package/lib/descriptors/action/action.descriptor.d.ts

@@ -1,23 +1,42 @@
 import { Type } from '@angular/core';
-import { Params, QueryParamsHandling } from '@angular/router';
-import { Observable } from 'rxjs';
-import { ModelDescriptor } from '../';
-import { ActionContext, ActionContextValidation, IActionComponent } from '../../components/action/models';
-import { IDataProvider, IEditorDataProvider } from '../../data-providers';
+import { ActionContext, IActionComponent } from '../../components/action/models';
+import { IDataProvider } from '../../data-providers';
 import { APermissions } from '../../security/model';
-import { StyleLevelEnum, StyleSizeEnum } from '../../styles/models';
-import { ClassType, IdType } from '../../types';
-import { EditorDescriptor } from '../editor';
-import { ActionActivationTriggerEnum, ActionEditorSubmitTypeEnum, ActionPositionEnum, ActionTypeEnum } from '../types';
+import { StyleLevelEnum } from '../../styles/models';
+import { ActionRunFnType, ActionValidationFnType, ClassType, ServiceClassType } from '../../types';
+import { ModelDescriptor } from '../model';
+import { ActionActivationTriggerEnum, ActionPositionEnum, ActionTypeEnum } from '../types';
 import { ActionButtonDescriptor } from './action-button.descriptor';
-import { ActionConfirmationDialogDescriptor } from './action-confirmation.descriptor';
-export declare class ActionDescriptor<T> {
-    protected readonly _model: ModelDescriptor<T> | null;
+import { ActionConfirmationDescriptor } from './action-confirmation.descriptor';
+export type ActionDescriptorConstructorOptsType<Model, Service> = ActionDescriptorCreateOptsParentType & ActionDescriptorCreateOptsProviderType<Model, Service> & {
+    model?: ModelDescriptor<Model>;
+};
+export type ActionDescriptorCreateFromClassOpts<Model> = ActionDescriptorCreateOptsModel<Model> & ActionDescriptorCreateOptsI18nType & ActionDescriptorCreateOptsParentType;
+export type ActionDescriptorCreateOptsProviderType<Model, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: IDataProvider<Model, Service>;
+};
+export type ActionDescriptorCreateOptsI18nType = {
+    i18nBaseKey?: string | ClassType<any>;
+};
+export type ActionDescriptorCreateOptsModel<Model> = {
+    idProperty?: keyof Model;
+    titleProperty?: keyof Model;
+};
+export type ActionDescriptorCreateOptsParentType = {
+    parentType?: ClassType<unknown>;
+    parentProperty?: string;
+};
+export type ActionProviderType<Model, Service> = ServiceClassType<Service> | IDataProvider<Model, Service>;
+export declare const actionGetProviderCfgObj: <Model, Service>(serviceOrDataProvider?: ActionProviderType<Model, Service> | undefined) => ActionDescriptorCreateOptsProviderType<Model, Service>;
+export declare class ActionDescriptorInst<Model, Service = any> {
+    protected readonly _model?: ModelDescriptor<Model>;
     protected readonly _actionName: string;
     protected readonly _actionNameLong: string;
     protected readonly _parentType?: ClassType<unknown>;
     protected readonly _parentTypeName?: string;
     protected readonly _parentProperty?: string;
+    protected readonly _dataProvider?: IDataProvider<Model, Service>;
     protected _i18nModelActionBaseKey?: string;
     protected _type: ActionTypeEnum;
     protected _activationTrigger: ActionActivationTriggerEnum;
@@ -26,27 +45,26 @@ export declare class ActionDescriptor<T> {
     private _positionTableviewCategories?;
     protected _tableviewCategory?: string;
     protected _routeUrl: string | null;
-    protected _dataProvider?: IDataProvider<T, any>;
-    protected _runFunction?: (ctx: ActionContext<T, any>) => Observable<T | undefined | null>;
-    protected _isVisibleFunction?: (ctx: ActionContextValidation<T, any>) => Observable<boolean>;
-    protected _isEnabledFunction?: (ctx: ActionContextValidation<T, any>) => Observable<boolean>;
-    protected _runConfirmationDialogDescriptor?: ActionConfirmationDialogDescriptor<T>;
+    protected _runFunction?: ActionRunFnType<Model, Service>;
+    protected _isVisibleFunction?: ActionValidationFnType<Model, Service>;
+    protected _isEnabledFunction?: ActionValidationFnType<Model, Service>;
+    protected _runConfirmationDialogDescriptor?: ActionConfirmationDescriptor<Model>;
     protected _hasRunNotificationSuccess: boolean;
     protected _runNotificationSuccessTitle?: string;
     protected _runNotificationSuccessMessage?: string;
     protected _hasRunNotificationError: boolean;
     protected _runNotificationErrorTitle?: string;
     protected _runNotificationErrorMessage?: string;
-    protected _afterRunAction?: ActionDescriptor<unknown> | ((ctx: ActionContext<T, any>) => ActionDescriptor<unknown>);
-    protected _onRunErrorAction?: ActionDescriptor<T> | ((ctx: ActionContext<T, any>) => ActionDescriptor<T>);
+    protected _afterRunAction?: ActionDescriptorInst<any> | ((ctx: ActionContext<Model, any>) => ActionDescriptorInst<any>);
+    protected _onRunErrorAction?: ActionDescriptorInst<Model> | ((ctx: ActionContext<Model, any>) => ActionDescriptorInst<Model>);
     protected _permissions?: APermissions;
     protected _button: ActionButtonDescriptor;
     protected _hasItemsSelection: boolean;
-    protected _component?: Type<IActionComponent<T>>;
+    protected _component?: Type<IActionComponent<Model>>;
     protected _subactionsAsMenu: boolean;
-    protected _subactions: Array<ActionDescriptor<T>>;
-    constructor(model: ModelDescriptor<T> | null, actionName: string, parentType?: ClassType<unknown>, parentProperty?: string);
-    get model(): ModelDescriptor<T> | null;
+    protected _subactions: Array<ActionDescriptorInst<Model>>;
+    protected constructor(actionName: string, cfg?: ActionDescriptorConstructorOptsType<Model, Service>);
+    get model(): ModelDescriptor<Model, import("../../types").ClassOptType<Model>> | undefined;
     get parentTypeName(): string | undefined;
     get parentProperty(): string | undefined;
     get i18nModelActionBaseKey(): string | undefined;
@@ -55,15 +73,15 @@ export declare class ActionDescriptor<T> {
     get position(): ActionPositionEnum;
     get level(): StyleLevelEnum;
     get routeUrl(): string | null;
-    get dataProvider(): IDataProvider<T, any> | undefined;
+    get dataProvider(): IDataProvider<Model, Service> | undefined;
     get hasRunFunction(): boolean;
-    get runFunction(): (ctx: ActionContext<T, any>) => Observable<T | undefined | null>;
-    get isVisibleFunction(): ((ctx: ActionContextValidation<T, any>) => Observable<boolean>) | undefined;
-    get isEnabledFunction(): ((ctx: ActionContextValidation<T, any>) => Observable<boolean>) | undefined;
+    get runFunction(): ActionRunFnType<Model, Service>;
+    get isVisibleFunction(): ActionValidationFnType<Model, Service> | undefined;
+    get isEnabledFunction(): ActionValidationFnType<Model, Service> | undefined;
     get actionName(): string;
     get actionNameLong(): string;
     get className(): string | undefined;
-    get runConfirmationDialogDescriptor(): ActionConfirmationDialogDescriptor<T> | undefined;
+    get runConfirmationDialogDescriptor(): ActionConfirmationDescriptor<Model> | undefined;
     get hasRunConfirmation(): boolean;
     get hasRunNotificationSuccess(): boolean;
     get runNotificationSuccessTitle(): string | undefined;
@@ -71,165 +89,61 @@ export declare class ActionDescriptor<T> {
     get hasRunNotificationError(): boolean;
     get runNotificationErrorTitle(): string | undefined;
     get runNotificationErrorMessage(): string | undefined;
-    get afterRunAction(): ActionDescriptor<unknown> | ((ctx: ActionContext<T, any>) => ActionDescriptor<unknown>) | undefined;
-    get onRunErrorAction(): ActionDescriptor<T> | ((ctx: ActionContext<T, any>) => ActionDescriptor<T>) | undefined;
+    get afterRunAction(): ActionDescriptorInst<any, any> | ((ctx: ActionContext<Model, any>) => ActionDescriptorInst<any, any>) | undefined;
+    get onRunErrorAction(): ActionDescriptorInst<Model, any> | ((ctx: ActionContext<Model, any>) => ActionDescriptorInst<Model, any>) | undefined;
     get permissions(): APermissions | undefined;
     get tableviewCategory(): string | undefined;
     get hasItemsSelection(): boolean;
     get button(): ActionButtonDescriptor;
-    get component(): Type<IActionComponent<T>> | undefined;
+    get component(): Type<IActionComponent<Model, undefined>> | undefined;
     get positionTableviewCategories(): string[] | undefined;
     get subactionsAsMenu(): boolean;
-    get subactions(): ActionDescriptor<T>[];
+    get subactions(): ActionDescriptorInst<Model, any>[];
     protected setI18nModelActionBaseKey(base?: string): void;
-    withDataProvider(dataProvider: IDataProvider<T, any>): this;
-    withServiceType<S>(serviceType: Type<S>): this;
-    withRunFunction<S>(fn: (ctx: ActionContext<T, S>) => Observable<T | undefined | null>): this;
-    withIsVisibleFunction<S>(fn: (ctx: ActionContextValidation<T, S>) => Observable<boolean>): this;
-    withIsEnabledFunction<S>(fn: (ctx: ActionContextValidation<T, S>) => Observable<boolean>): this;
+    withRunFunction(fn: ActionRunFnType<Model, Service>): this;
+    withIsVisibleFunction(fn?: ActionValidationFnType<Model, Service>): this;
+    withIsEnabledFunction(fn?: ActionValidationFnType<Model, Service>): this;
     withRouteTrigger(routeUrl: string): this;
     withPosition(position: ActionPositionEnum): this;
     /**
      * creates confirmation action with default style based on action descriptor
      */
-    withRunConfirmation(): ActionConfirmationDialogDescriptor<T>;
+    withRunConfirmation(): ActionConfirmationDescriptor<Model>;
     /**
      * Add a configuration dialogue to action using ActionConfigurationDescriptor
      * @param runConfirmationDialogDescriptor descriptor with customizable information for dialog
      */
-    withRunConfirmationDescriptor(runConfirmationDialogDescriptor: ActionConfirmationDialogDescriptor<T>): this;
+    withRunConfirmationDescriptor(runConfirmationDialogDescriptor?: ActionConfirmationDescriptor<Model>): this;
     withRunNotificationSuccess(title?: string, message?: string, hasNotification?: boolean): this;
     withRunNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
-    withAfterRunAction<RT, S = any>(action: ActionDescriptor<RT> | ((ctx: ActionContext<T, S>) => ActionDescriptor<RT>)): this;
-    withOnRunErrorAction<S = any>(action: ActionDescriptor<T> | ((ctx: ActionContext<T, S>) => ActionDescriptor<T>)): this;
+    withAfterRunAction<Return, Service = any>(action?: ActionDescriptorInst<Return> | ((ctx: ActionContext<Model, Service>) => ActionDescriptorInst<Return>)): this;
+    withOnRunErrorAction<S = any>(action?: ActionDescriptorInst<Model> | ((ctx: ActionContext<Model, S>) => ActionDescriptorInst<Model>)): this;
     withPermissions(permissions: APermissions): this;
     withTableviewCategory(permissionsRouteType: string): this;
     withButtonDescriptor(button: ActionButtonDescriptor): this;
     withButton(label?: string | null, icon?: string | null, styleLevel?: StyleLevelEnum, styleText?: boolean): this;
     withItemsSelection(hasSelection?: boolean): this;
-    withComponent(component: Type<IActionComponent<T>>): this;
+    withComponent(component: Type<IActionComponent<Model>>): this;
     withPositionTableviewCategories(positionTableviewCategories: string[]): this;
     withI18nBase(base: ClassType<unknown> | string): this;
-    withSubactionsAsMenu(): this;
-    withSubactions(...subactions: Array<ActionDescriptor<T>>): this;
-    copyTo(descriptor: ActionDescriptor<T>): ActionDescriptor<T>;
+    withSubactionsAsMenu(subactionsAsMenu?: boolean): this;
+    withSubactions(...subactions: Array<ActionDescriptorInst<Model>>): this;
+    copyTo(descriptor: ActionDescriptorInst<Model, Service>): ActionDescriptorInst<Model, Service>;
 }
-export declare class ActionSimpleDescriptor<T> extends ActionDescriptor<T> {
-    constructor(actionName: string, modelType?: ClassType<T>, idProperty?: string, titleProperty?: string, i18nBaseKey?: string | ClassType<unknown>);
+export declare class ActionDescriptor extends ActionDescriptorInst<any> {
+    protected constructor();
+    static create<Model>(actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined>;
+    static createWithProvider<Service, Model>(serviceProvider: ActionProviderType<Model, Service>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, Service>;
+    static fromModel<Model>(model: ModelDescriptor<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined>;
+    static fromModelWithProvider<Model, Service>(model: ModelDescriptor<Model>, serviceProvider: ActionProviderType<Model, Service>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, Service>;
+    static fromClass<Model>(type: ClassType<Model>, actionName: string, cfg?: ActionDescriptorCreateFromClassOpts<Model>): ActionDescriptorInst<Model, undefined>;
+    static fromClassWithProvider<Model, Service>(classType: ClassType<Model>, serviceProvider: ActionProviderType<Model, Service>, actionName: string, cfg?: ActionDescriptorCreateFromClassOpts<Model>): ActionDescriptorInst<Model, Service>;
 }
-export declare class ActionEditorDescriptor<T> extends ActionDescriptor<T> {
-    private readonly _editorDescriptor;
-    protected _editorActions: ActionDescriptor<T>[];
-    protected _editorTitle?: string | null;
-    protected _editorTitleParams?: any;
-    protected _hasFetchNotificationSuccess: boolean;
-    protected _fetchNotificationSuccessTitle?: string;
-    protected _fetchNotificationSuccessMessage?: string;
-    protected _dialogSize: StyleSizeEnum;
-    protected _dialogClassName?: string;
-    protected _dataProvider?: IEditorDataProvider<T, any>;
-    protected _fetchFunction?: (ctx: ActionContext<T, any>) => Observable<T>;
-    protected _submitFunction?: (ctx: ActionContext<T, any>) => Observable<T>;
-    protected _editorComponent?: Type<any>;
-    protected _resubmitEnabled?: boolean;
-    protected _resubmitRefetch: boolean;
-    protected _unsavedChangesConfirmation: boolean;
-    constructor(editorDescriptor: EditorDescriptor<T>, actionName: string, parentType?: ClassType<unknown>, parentProperty?: string);
-    get editorTitle(): string | null | undefined;
-    get editorTitleParams(): any;
-    get editorDescriptor(): EditorDescriptor<T>;
-    get dialogSize(): StyleSizeEnum;
-    get dialogClassName(): string | undefined;
-    get hasFetchNotificationSuccess(): boolean;
-    get fetchNotificationSuccessTitle(): string | undefined;
-    get fetchNotificationSuccessMessage(): string | undefined;
-    get dataProvider(): IEditorDataProvider<T, any> | undefined;
-    get runFunction(): (ctx: ActionContext<T, unknown>) => Observable<T>;
-    get fetchFunction(): ((ctx: ActionContext<T, any>) => Observable<T>) | undefined;
-    get submitFunction(): ((ctx: ActionContext<T, any>) => Observable<T>) | undefined;
-    get editorActions(): ActionDescriptor<T>[];
-    get editorComponent(): Type<any> | undefined;
-    get resubmitEnabled(): boolean | undefined;
-    get resubmitRefetch(): boolean;
-    get unsavedChangesConfirmation(): boolean;
-    withEditorTitle(title: string | null, params?: any): this;
-    withDataProvider(dataProvider: IEditorDataProvider<T, any>): this;
-    withServiceType<S>(serviceType: Type<S>): this;
-    withDialogSize(size?: StyleSizeEnum): this;
-    withDialogClassName(className: string): this;
-    withRunFunction<S>(fn: (ctx: ActionContext<T, S>) => Observable<T>): this;
-    withFetchFunction<S>(fn: (ctx: ActionContext<T, S>) => Observable<T>): this;
-    withSubmitFunction<S>(fn: (ctx: ActionContext<T, S>) => Observable<T>): this;
-    withFetchNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
-    withEditorAction(action: ActionDescriptor<T>): this;
-    withEditorActions(actions: ActionDescriptor<T>[]): this;
-    withEditorComponent(editorComponent: Type<any>): this;
-    withResubmit(enabled?: boolean, refetch?: boolean): this;
-    withUnsavedChangesConfirmation(unsavedChangesConfirmation?: boolean): this;
-}
-export declare class ActionEditorSubmitDescriptor<T> extends ActionDescriptor<T> {
-    private readonly _editorAction;
-    private readonly _submitType;
-    constructor(editorAction: ActionEditorDescriptor<T>, submitType?: ActionEditorSubmitTypeEnum);
-    /**
-     * creates primary action with primary button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forPrimary<T>(editorAction: ActionEditorDescriptor<T>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptor<T>;
-    /**
-     * creates secondary button with text button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forSecondary<T>(editorAction: ActionEditorDescriptor<T>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptor<T>;
-    get submitType(): ActionEditorSubmitTypeEnum;
-}
-export declare class ActionEditorDetailsDescriptor<T> extends ActionEditorDescriptor<T> {
-    static readonly ACTION_NAME = "details";
-    constructor(editorDescriptor: EditorDescriptor<T>);
-    withServiceType<S>(serviceType: Type<S>): this;
-    withServiceFetchFunction<S>(serviceType: Type<S>, fetchFn?: (id: IdType, service?: S) => Observable<T>): this;
-}
-export declare class ActionEditorAddDescriptor<T> extends ActionEditorDescriptor<T> {
-    static readonly ACTION_NAME = "add";
-    constructor(editorDescriptor: EditorDescriptor<T>);
-    withServiceType<S>(serviceType: Type<S>): this;
-    withServiceSubmitFunction<S>(serviceType: Type<S>, createFn?: (item?: T, service?: S) => Observable<T>, fetchFn?: (id: IdType, service?: S) => Observable<T>): this;
-}
-export declare class ActionEditorEditDescriptor<T> extends ActionEditorDescriptor<T> {
-    static readonly ACTION_NAME = "edit";
-    constructor(editorDescriptor: EditorDescriptor<T>);
-    withServiceType<S>(serviceType: Type<S>): this;
-    withServiceSubmitFunction<S>(serviceType: Type<S>, updateFn?: (id: IdType, item?: T, service?: S) => Observable<T>, fetchFn?: (id: IdType, service?: S) => Observable<T>): this;
-}
-export declare class ActionDeleteDescriptor<T> extends ActionDescriptor<T> {
+export declare class ActionDeleteDescriptorInst<Model, Service = any> extends ActionDescriptorInst<Model, Service> {
     static readonly ACTION_NAME = "delete";
-    constructor(model: ModelDescriptor<T>);
-    withServiceType<S>(serviceType: Type<S>): this;
-    withServiceDeleteFunction<S>(serviceType: Type<S>, deleteFn?: (id: IdType, item?: T, service?: S) => Observable<T>): this;
+    constructor(model: ModelDescriptor<Model>, cfg?: ActionDescriptorCreateOptsProviderType<Model, Service>);
 }
-export declare class ActionLinkDescriptor<T> extends ActionDescriptor<T> {
-    private _url;
-    private _pathSegments;
-    private _queryParams?;
-    private _queryParamsHandling?;
-    private _replaceUrl;
-    private _target;
-    private _isStyleLink;
-    constructor(model?: ModelDescriptor<T> | null, actionName?: string);
-    static fromActionDescriptor<T>(actionDescriptor: ActionDescriptor<T>): ActionLinkDescriptor<T>;
-    get url(): string;
-    get pathSegments(): string[];
-    get queryParams(): Params | undefined;
-    get queryParamsHandling(): QueryParamsHandling | undefined;
-    get replaceUrl(): boolean;
-    get target(): string;
-    get isStyleLink(): boolean;
-    withHref(url: string): this;
-    withRouterLink(...pathSegments: string[]): this;
-    withQueryParams(queryParams: Params, queryParamsHandling?: QueryParamsHandling): this;
-    withReplaceUrl(replaceUrl?: boolean): this;
-    withTarget(target?: '_self' | '_blank'): this;
-    withStyleLink(isStyleLink: boolean): this;
+export declare class ActionDeleteDescriptor {
+    static create<Model>(model: ModelDescriptor<Model>): ActionDeleteDescriptorInst<Model, undefined>;
+    static createWithProvider<Model, Service>(model: ModelDescriptor<Model>, serviceProvider: ActionProviderType<Model, Service>): ActionDeleteDescriptorInst<Model, Service>;
 }

package/lib/descriptors/action/index.d.ts

@@ -1,3 +1,5 @@
 export * from './action.descriptor';
+export * from './action-editor.descriptor';
+export * from './action-link.descriptor';
 export * from './action-button.descriptor';
 export * from './action-confirmation.descriptor';