@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.0

package/tableview/api/action/descriptors/action-confirmation.descriptor.d.ts

@@ -0,0 +1,36 @@
+import { Confirmation } from 'primeng/api';
+import { ActionButtonDescriptor } from '@mediusinc/mng-commons/form/api';
+import { IActionContext } from '../models/execution/action-context.model';
+export declare class ActionConfirmationDescriptor<Model> {
+    private _icon?;
+    private _title?;
+    private _message?;
+    private _acceptButton;
+    private _rejectButton?;
+    private _closeOnEscape;
+    private _closable;
+    private _runConfirmationConfigMapFn?;
+    constructor();
+    withIcon(icon?: string): this;
+    withTitle(title?: string | null): this;
+    withMessage(message?: string | null): this;
+    withAcceptButton(actionButtonDescriptor: ActionButtonDescriptor): this;
+    withRejectButton(actionButtonDescriptor?: ActionButtonDescriptor): this;
+    /**
+     * set if dialog can be closed on escaped pressed
+     * if true, then closable is also set to true
+     * @param closeOnEscape
+     */
+    withCloseOnEscape(closeOnEscape: boolean): this;
+    withClosable(closable: boolean): 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<Model> | undefined;
+    get acceptButton(): ActionButtonDescriptor;
+    get rejectButton(): ActionButtonDescriptor | undefined;
+}
+export type ConfigurationConfigMapFn<Item> = (ctx: IActionContext<Item, any>, confirmConfig: Confirmation) => Confirmation;

package/tableview/api/action/descriptors/action-editor.descriptor.d.ts

@@ -0,0 +1,117 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ServiceClassType, StyleSizeEnum } from '@mediusinc/mng-commons/core';
+import { ModelDescriptor } from '@mediusinc/mng-commons/model';
+import { IEditorDataProvider } from '../../editor/data-providers/editor.data-provider';
+import { EditorDescriptorInst } from '../../editor/descriptors/editor.descriptor';
+import { ActionEditorSubmitTypeEnum } from '../models/action.type';
+import { IActionContext } from '../models/execution/action-context.model';
+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<Item, Service = any> extends ActionDescriptorInst<Item, Service> {
+    private readonly _editorDescriptor;
+    protected readonly _dataProvider?: IEditorDataProvider<Item, any>;
+    protected _editorActions: ActionDescriptorInst<Item>[];
+    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: IActionContext<Item, Service>) => Observable<Item>;
+    protected _submitFunction?: (ctx: IActionContext<Item, Service>) => Observable<Item>;
+    protected _editorComponent?: Type<any>;
+    protected _resubmitEnabled?: boolean;
+    protected _resubmitRefetch: boolean;
+    protected _unsavedChangesConfirmation: boolean;
+    constructor(editorDescriptor: EditorDescriptorInst<Item>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Item, Service>);
+    get editorTitle(): string | null | undefined;
+    get editorTitleParams(): any;
+    get editorDescriptor(): EditorDescriptorInst<Item>;
+    get dialogSize(): StyleSizeEnum;
+    get dialogClassName(): string | undefined;
+    get hasFetchNotificationSuccess(): boolean;
+    get fetchNotificationSuccessTitle(): string | undefined;
+    get fetchNotificationSuccessMessage(): string | undefined;
+    get dataProvider(): IEditorDataProvider<Item, any> | undefined;
+    get hasRunFunction(): boolean;
+    get runFunction(): (ctx: IActionContext<Item, unknown>) => Observable<Item>;
+    get hasFetchFunction(): boolean;
+    get fetchFunction(): ((ctx: IActionContext<Item, Service, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Item, Service>, import("@mediusinc/mng-commons/tableview/api").IViewContainer<Item, Service, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Item, Service>>>) => Observable<Item>) | undefined;
+    get hasSubmitFunction(): boolean;
+    get submitFunction(): ((ctx: IActionContext<Item, Service, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Item, Service>, import("@mediusinc/mng-commons/tableview/api").IViewContainer<Item, Service, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Item, Service>>>) => Observable<Item>) | undefined;
+    get editorActions(): ActionDescriptorInst<Item, 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: IActionContext<Item, Service>) => Observable<Item>): this;
+    withFetchFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this;
+    withSubmitFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this;
+    withFetchNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
+    withEditorAction(action: ActionDescriptorInst<Item>): this;
+    withEditorActions(actions: ActionDescriptorInst<Item>[]): 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/tableview/api/action/descriptors/action-link.descriptor.d.ts

@@ -0,0 +1,34 @@
+import { Params, QueryParamsHandling } from '@angular/router';
+import { ClassType } from '@mediusinc/mng-commons/core';
+import { ModelDescriptor } from '@mediusinc/mng-commons/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/tableview/api/action/descriptors/action.descriptor.d.ts

@@ -0,0 +1,151 @@
+import { InjectionToken, Type } from '@angular/core';
+import { APermissions, ClassType, IActionDescriptorInternal, IDataProvider, ServiceClassType, StyleLevelEnum } from '@mediusinc/mng-commons/core';
+import { ActionButtonDescriptor } from '@mediusinc/mng-commons/form/api';
+import { ModelDescriptor } from '@mediusinc/mng-commons/model';
+import { IActionComponent } from '../models/action-component.model';
+import { ActionRunFnType, ActionValidationFnType } from '../models/action-descriptor.types';
+import { ActionActivationTriggerEnum, ActionPositionEnum, ActionTypeEnum } from '../models/action.type';
+import { IActionContext } from '../models/execution/action-context.model';
+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> implements IActionDescriptorInternal<Model, Service> {
+    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;
+    protected _position: ActionPositionEnum;
+    protected _level: StyleLevelEnum;
+    private _positionTableviewCategories?;
+    protected _tableviewCategory?: string;
+    protected _routeUrl: string | null;
+    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?: ActionDescriptorInst<any> | ((ctx: IActionContext<Model, any>) => ActionDescriptorInst<any>);
+    protected _onRunErrorAction?: ActionDescriptorInst<Model> | ((ctx: IActionContext<Model, any>) => ActionDescriptorInst<Model>);
+    protected _permissions?: APermissions;
+    protected _button: ActionButtonDescriptor;
+    protected _hasItemsSelection: boolean;
+    protected _component?: Type<IActionComponent<Model>>;
+    protected _componentFromDi?: InjectionToken<Type<any>>;
+    protected _subactionsAsMenu: boolean;
+    protected _subactions: Array<ActionDescriptorInst<Model>>;
+    protected constructor(actionName: string, cfg?: ActionDescriptorConstructorOptsType<Model, Service>);
+    get model(): ModelDescriptor<Model, import("@mediusinc/mng-commons/core").ClassOptType<Model>> | undefined;
+    get parentTypeName(): string | undefined;
+    get parentProperty(): string | undefined;
+    get i18nModelActionBaseKey(): string | undefined;
+    get type(): ActionTypeEnum;
+    get activationTrigger(): ActionActivationTriggerEnum;
+    get position(): ActionPositionEnum;
+    get level(): StyleLevelEnum;
+    get routeUrl(): string | null;
+    get dataProvider(): IDataProvider<Model, Service> | undefined;
+    get hasRunFunction(): boolean;
+    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(): ActionConfirmationDescriptor<Model> | undefined;
+    get hasRunConfirmation(): boolean;
+    get hasRunNotificationSuccess(): boolean;
+    get runNotificationSuccessTitle(): string | undefined;
+    get runNotificationSuccessMessage(): string | undefined;
+    get hasRunNotificationError(): boolean;
+    get runNotificationErrorTitle(): string | undefined;
+    get runNotificationErrorMessage(): string | undefined;
+    get afterRunAction(): ActionDescriptorInst<any, any> | ((ctx: IActionContext<Model, any, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Model, any>, import("@mediusinc/mng-commons/tableview/api").IViewContainer<Model, any, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Model, any>>>) => ActionDescriptorInst<any, any>) | undefined;
+    get onRunErrorAction(): ActionDescriptorInst<Model, any> | ((ctx: IActionContext<Model, any, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Model, any>, import("@mediusinc/mng-commons/tableview/api").IViewContainer<Model, any, import("@mediusinc/mng-commons/tableview/api").IActionInstance<Model, any>>>) => ActionDescriptorInst<Model, any>) | undefined;
+    get permissions(): APermissions | undefined;
+    get tableviewCategory(): string | undefined;
+    get hasItemsSelection(): boolean;
+    get button(): ActionButtonDescriptor;
+    get component(): Type<IActionComponent<Model, undefined>> | undefined;
+    get componentFromDi(): InjectionToken<Type<any>> | undefined;
+    get positionTableviewCategories(): string[] | undefined;
+    get subactionsAsMenu(): boolean;
+    get subactions(): ActionDescriptorInst<Model, any>[];
+    protected setI18nModelActionBaseKey(base?: string): void;
+    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(): ActionConfirmationDescriptor<Model>;
+    /**
+     * Add a configuration dialogue to action using ActionConfigurationDescriptor
+     * @param runConfirmationDialogDescriptor descriptor with customizable information for dialog
+     */
+    withRunConfirmationDescriptor(runConfirmationDialogDescriptor?: ActionConfirmationDescriptor<Model>): this;
+    withRunNotificationSuccess(title?: string, message?: string, hasNotification?: boolean): this;
+    withRunNotificationError(title?: string, message?: string, hasNotification?: boolean): this;
+    withAfterRunAction<Return, Service = any>(action?: ActionDescriptorInst<Return> | ((ctx: IActionContext<Model, Service>) => ActionDescriptorInst<Return>)): this;
+    withOnRunErrorAction<S = any>(action?: ActionDescriptorInst<Model> | ((ctx: IActionContext<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<Model>>): this;
+    withComponentFromDi(injectionToken: InjectionToken<Type<any>>): this;
+    withPositionTableviewCategories(positionTableviewCategories: string[]): this;
+    withI18nBase(base: ClassType<unknown> | string): this;
+    withSubactionsAsMenu(subactionsAsMenu?: boolean): this;
+    withSubactions(...subactions: Array<ActionDescriptorInst<Model>>): this;
+    copyTo(descriptor: ActionDescriptorInst<Model, Service>): ActionDescriptorInst<Model, Service>;
+}
+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 ActionDeleteDescriptorInst<Model, Service = any> extends ActionDescriptorInst<Model, Service> {
+    static readonly ACTION_NAME = "delete";
+    constructor(model: ModelDescriptor<Model>, cfg?: ActionDescriptorCreateOptsProviderType<Model, Service>);
+}
+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/tableview/api/action/helpers/data-provider-executors.d.ts

@@ -0,0 +1,18 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataListResult, IDataProvider } from '@mediusinc/mng-commons/core';
+import { IActionContext } from '../models/execution/action-context.model';
+export declare function runFnFromDataProviderOrFallback<Item, Service, Return, FallbackReturn = Return>(ctx: IActionContext<Item, Service>, fn: (ctx: IActionContext<Item, Service>) => Observable<Return> | null, fallback: Observable<FallbackReturn>): Observable<Return | FallbackReturn>;
+export declare function runFnFromDataProviderOrFail<Item, Service, Return>(ctx: IActionContext<Item, Service>, fn: (ctx: IActionContext<Item, Service>) => Observable<Return> | null): Observable<Return>;
+export declare function runGetAllFromDataProvider<Item, Service>(ctx: IActionContext<Item, Service>): Observable<DataListResult<Item>> | null;
+export declare function runFetchFromDataProvider<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
+export declare function runCreateFromDataProvider<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
+export declare function runUpdateFromDataProvider<Item, service>(ctx: IActionContext<Item, service>): Observable<Item> | null;
+export declare function runDeleteFromDataProvider<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item | null> | null;
+/**
+ * Gets service instance of data provider.
+ *
+ * @param injector Injector instance
+ * @param dataProvider Data provider instance.
+ */
+export declare function getDataProviderService<Item, Service>(injector: Injector, dataProvider?: IDataProvider<Item, Service>): Service | null;

package/tableview/api/action/models/action-component.model.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { ActionData, ActionParameters, IdType } from '@mediusinc/mng-commons/core';
+import { ActionDescriptorInst } from '../descriptors/action.descriptor';
+export interface IActionComponent<Item = any, Service = undefined> {
+    action: ActionDescriptorInst<Item, Service>;
+    item: Item;
+    itemId: IdType;
+    actionData: ActionData;
+    enabled: boolean;
+    loading: boolean;
+    triggerActionEventEmitter: EventEmitter<ActionParameters<Item>>;
+}

package/tableview/api/action/models/action-descriptor.types.d.ts

@@ -0,0 +1,5 @@
+import { ItemOrObservable } from '@mediusinc/mng-commons/core';
+import { ActionContextValidation } from './execution/action-context-validation.model';
+import { IActionContext } from './execution/action-context.model';
+export type ActionRunFnType<Item, Service = undefined, Return = ItemOrObservable<Item | undefined | null>> = (ctx: IActionContext<Item, Service>) => Return;
+export type ActionValidationFnType<Item, Service = undefined, Return = ItemOrObservable<boolean>> = (ctx: ActionContextValidation<Item, Service>) => Return;

package/tableview/api/action/models/action-editor.model.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+export interface IActionEditorComponent {
+    closeWithUnsavedChangesConfirmation(callFromGuard: boolean): Observable<boolean>;
+}

package/tableview/api/action/models/action-error.model.d.ts

@@ -0,0 +1,14 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { ACommonsErrorBase, CommonsErrorBaseOptions, ICommonsActionError } from '@mediusinc/mng-commons/core';
+import { IActionContext } from './execution/action-context.model';
+export interface CommonsActionErrorOptions extends CommonsErrorBaseOptions {
+    actionContext?: IActionContext<any, any>;
+    httpError?: HttpErrorResponse;
+}
+export declare class CommonsActionError extends ACommonsErrorBase implements ICommonsActionError {
+    readonly type = "CommonsActionError";
+    readonly actionId: string;
+    readonly actionContext?: IActionContext<any, any>;
+    readonly httpError?: HttpErrorResponse;
+    constructor(message: string, actionName: string, options?: CommonsActionErrorOptions);
+}

package/tableview/api/action/models/execution/action-context-validation.model.d.ts

@@ -0,0 +1,11 @@
+import { ActionParameters, IDataProvider } from '@mediusinc/mng-commons/core';
+import { ActionDescriptorInst } from '../../descriptors/action.descriptor';
+/**
+ * Class containing all main data for action validations (enabled/visible) to be executed in validation states.
+ */
+export interface ActionContextValidation<Item, Service = undefined> {
+    descriptor: ActionDescriptorInst<Item, Service>;
+    parameters: ActionParameters<Item>;
+    serviceInstance: Service;
+    dataProvider?: IDataProvider<Item, Service>;
+}

package/tableview/api/action/models/execution/action-context.model.d.ts

@@ -0,0 +1,24 @@
+import { Injector } from '@angular/core';
+import { Confirmation, Message } from 'primeng/api';
+import { Observable } from 'rxjs';
+import { ActionParameters, IDataProvider } from '@mediusinc/mng-commons/core';
+import { IActionInstance } from './action-instance.model';
+import { IViewContainer } from './view-container.model';
+/**
+ * Class containing all main data for action to be executed in run/fetch/submit states.
+ */
+export interface IActionContext<Item, Service = undefined, Instance extends IActionInstance<Item, Service> = IActionInstance<Item, Service>, ViewContainer extends IViewContainer<Item, Service, Instance> = IViewContainer<Item, Service, Instance>> {
+    contextLongName: string;
+    instance: Instance;
+    parameters: ActionParameters<Item>;
+    functionName: 'run' | 'fetch' | 'submit';
+    serviceInstance: Service;
+    dataProvider?: IDataProvider<Item, Service>;
+    viewContainer?: ViewContainer;
+    injector: Injector;
+    previousActionInstance?: IActionInstance<any, any>;
+    confirmation?: Confirmation;
+    notification?: Message;
+    execution$: Observable<Item | null | undefined>;
+    executionIsRunning$: Observable<boolean>;
+}

package/tableview/api/action/models/execution/action-execution-error.model.d.ts

@@ -0,0 +1,4 @@
+export interface ActionExecutionError {
+    error: any;
+    dismissed: boolean;
+}

package/tableview/api/action/models/execution/action-instance-state.model.d.ts

@@ -0,0 +1,30 @@
+/**
+ * States of action. Enums ending with `*Final` are supposed to be final.
+ */
+export declare enum ActionInstanceStateEnum {
+    TriggerStart = 0,
+    TriggerEnd = 1,
+    ActivationStart = 2,
+    ActivationEnd = 3,
+    FetchStart = 4,
+    FetchEnd = 5,
+    FetchError = 6,
+    RunConfirmationStart = 7,
+    RunConfirmationEndAccept = 8,
+    RunConfirmationEndReject = 9,
+    RunStart = 10,
+    RunEnd = 11,
+    RunError = 12,
+    NextActionStart = 13,
+    NextActionEnd = 14,
+    ErrorActionStart = 15,
+    ErrorActionEnd = 16,
+    FinishSuccessFinal = 17,
+    FinishErrorFinal = 18,
+    FinishDismissedFinal = 19,
+    FinishSuccessReactivateFinal = 20,
+    FinishComponentDestroyFinal = 21,
+    FinishRouteUntriggerStart = 22,
+    FinishRouteUntriggerEndFinal = 23,
+    FinishRouteUntriggerTimeoutFinal = 24
+}

package/tableview/api/action/models/execution/action-instance.model.d.ts

@@ -0,0 +1,31 @@
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { Observable } from 'rxjs';
+import { ActionParameters } from '@mediusinc/mng-commons/core';
+import { ActionDescriptorInst } from '../../descriptors/action.descriptor';
+import { IActionEditorComponent } from '../action-editor.model';
+import { ActionExecutionError } from './action-execution-error.model';
+import { ActionInstanceStateEnum } from './action-instance-state.model';
+export interface IActionInstance<Item, Service> {
+    instanceId: string;
+    instanceLongName: string;
+    action: ActionDescriptorInst<Item>;
+    createdDate: Date;
+    triggerParameters?: ActionParameters<Item>;
+    activationParameters?: ActionParameters<Item>;
+    state: ActionInstanceStateEnum;
+    state$: Observable<ActionInstanceStateEnum>;
+    isRunLoading$: Observable<boolean>;
+    execution$: Observable<Item | null | undefined>;
+    executionIsRunning$: Observable<boolean>;
+    result?: Item | null;
+    result$: Observable<Item | null | undefined>;
+    error?: ActionExecutionError;
+    error$: Observable<ActionExecutionError>;
+    activationDialogRef?: DynamicDialogRef;
+    activationEditorComponentRef?: IActionEditorComponent;
+    previousInstance?: IActionInstance<Item, Service>;
+    nextActionInstance?: IActionInstance<any, any>;
+    errorActionInstance?: IActionInstance<Item, Service>;
+    reactivationInstance?: IActionInstance<Item, Service>;
+    reactivationInstance$: Observable<IActionInstance<Item, Service>>;
+}

package/tableview/api/action/models/execution/view-container.model.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { DataListParams, IDataProvider } from '@mediusinc/mng-commons/core';
+import { ActionDescriptorInst } from '../../descriptors/action.descriptor';
+import { IActionInstance } from './action-instance.model';
+export interface IViewContainer<Item, Service, ActionInstance extends IActionInstance<Item, Service> = IActionInstance<Item, Service>> {
+    dataProvider?: IDataProvider<Item, Service>;
+    routeTriggeredActionInstance?: ActionInstance;
+    actions: Array<ActionDescriptorInst<Item>>;
+    tableReload$: Observable<ViewContainerTableReloadEvent>;
+    editorReset$: Observable<ViewContainerEditorResetEvent<Item>>;
+    editorClose$: Observable<ViewContainerEditorCloseEvent<Item>>;
+    reloadTable(event?: ViewContainerTableReloadEvent): void;
+    resetEditor(event?: ViewContainerEditorResetEvent<Item> | undefined): void;
+    closeEditor(event?: ViewContainerEditorCloseEvent<Item>): void;
+}
+export interface ViewContainerTableReloadEvent {
+    emitEvent?: boolean;
+    resetParams?: boolean;
+    params?: DataListParams;
+    data?: {
+        [key: string]: any;
+    };
+}
+export interface ViewContainerEditorResetEvent<T> {
+    emitEvent?: boolean;
+    fetch?: boolean;
+    item?: T;
+    fields?: {
+        [key: string]: unknown;
+    };
+    data?: {
+        [key: string]: any;
+    };
+}
+export interface ViewContainerEditorCloseEvent<T> {
+    emitEvent?: boolean;
+    item?: T;
+}

package/tableview/api/action/services/data-provider-executor.service.d.ts

@@ -0,0 +1,38 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataListResult, IDataProvider, Nullable } from '@mediusinc/mng-commons/core';
+import { IActionContext } from '../models/execution/action-context.model';
+export declare abstract class DataProviderExecutor {
+    runGetAllOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<DataListResult<Item>>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<DataListResult<Item>>): Observable<DataListResult<Item>> | null;
+    runFetchOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
+    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
+    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runFetch<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runCreateOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
+    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
+    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runCreate<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runUpdateOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item>;
+    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item> | null;
+    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runUpdate<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runDeleteOrFail<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Item | null>;
+    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, Service>(ctx: IActionContext<Item, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    /**
+     * Gets service instance of data provider.
+     *
+     * @param injector Injector instance
+     * @param dataProvider Data provider instance.
+     */
+    getDataProviderService<Item, Service>(injector: Injector, dataProvider?: IDataProvider<Item, Service>): Service | null;
+}

package/tableview/api/action/services/tokens/data-language-dropdown.token.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken, Type } from '@angular/core';
+export declare const DATA_LANGUAGE_DROPDOWN_COMPONENT_IT: InjectionToken<Type<any>>;