@smallpearl/ngx-helper 0.33.50 → 20.0.2

package/mat-entity-crud/index.d.ts

@@ -1,6 +1,1075 @@
-export * from './src/convert-context-input-to-http-context';
-export * from './src/mat-entity-crud-form-base';
-export * from './src/mat-entity-crud-types';
-export * from './src/mat-entity-crud.component';
-export * from './src/preview-pane.component';
-export * from './src/providers';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, ChangeDetectorRef, InputSignal, TemplateRef, EmbeddedViewRef, ViewContainerRef, QueryList, EventEmitter, Injector } from '@angular/core';
+import { HttpContextToken, HttpContext, HttpParams, HttpClient } from '@angular/common/http';
+import { SPContextMenuItem } from '@smallpearl/ngx-helper/mat-context-menu';
+import { Observable, Subscription } from 'rxjs';
+import { AbstractControl } from '@angular/forms';
+import { TranslocoService } from '@jsverse/transloco';
+import * as _smallpearl_ngx_helper_entity_field from '@smallpearl/ngx-helper/entity-field';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { MatColumnDef } from '@angular/material/table';
+import { DomSanitizer } from '@angular/platform-browser';
+import { SPMatEntityListComponent } from '@smallpearl/ngx-helper/mat-entity-list';
+
+/**
+ * Prototype of the function to parse the CRUD action response.
+ */
+type SPMatEntityCrudResponseParser = (entityName: string, idKey: string, method: string, // 'create' | 'retrieve' | 'update' | 'delete',
+resp: any) => any | undefined;
+/**
+ * Global config for SPMatEntityList component.
+ */
+interface SPMatEntityCrudConfig {
+    /**
+     * The item actions that will be shown for each item in the list.
+     * This defaults to 'Update' & 'Delete' actions, but can be customized
+     * by this property. Note the item actions can be set for individual
+     * <sp-mat-entity-crud> component through its itemActions property.
+     */
+    defaultItemActions?: SPContextMenuItem[];
+    /**
+     * Global crud response parser.
+     */
+    crudOpResponseParser?: SPMatEntityCrudResponseParser;
+}
+/**
+ * This is the interface through which the client provided CRUD form component
+ * interacts with the 'host' SPMatEntityCrudComponent. When the form wants to
+ * submit an entity to the server (for create or update), it should call the
+ * one of the create or update methods. The interface also provides other
+ * methods for the form component to interact with SPMatEntityCrudComponent
+ * such as refresh its entities list, close the form pane, etc.
+ *
+ * The interface name has a 'Bridge' as the interface acts as a bridge between
+ * the client provided form handler component and the host
+ * SPMatEntityCrudComponent.
+ */
+interface SPMatEntityCrudCreateEditBridge {
+    /**
+     * Returns the entity name as provided to the host SPMatEntityCrudComponent.
+     * @returns The entity name string.
+     */
+    getEntityName(): string;
+    /**
+     * Returns the entity id key as provided to the host SPMatEntityCrudComponent.
+     * @returns The entity id key string.
+     */
+    getIdKey(): string;
+    /**
+     * Get Entity url
+     * @param cancel
+     * @returns
+     */
+    getEntityUrl(entityId: any): string;
+    /**
+     * Close the edit/update form pane. This WON'T call the 'cancelEditCallback'
+     * even if one is registered.
+     */
+    close: (cancel: boolean) => void;
+    /**
+     * Client form view can register a callback that will be invoked by the
+     * framework when user cancels the create/edit operation by clicking on the
+     * close button on the top right.
+     * @param callback
+     * @returns None
+     */
+    registerCanCancelEditCallback: (callback: () => boolean) => void;
+    /**
+     * Create a new instance of TEntity, by sending a POST request to remote.
+     * @param entityValue This is the typically the output of Reactive form's
+     * form.value. Since this value's shape may be different from TEntity and is
+     * known only to client form, we use 'any'.
+     * @returns None
+     * @inner Implementation will show a busy wheel centered on the form
+     * view while the async function to update the object remains active.
+     */
+    create: (entityValue: any) => Observable<any>;
+    /**
+     * Update the entity with id `id` with new values in entityValue.
+     * @param id TEntity id
+     * @param entityValue Entity values to be updated.
+     * @returns None
+     * @inner Implementation will show a busy wheel centered on the form
+     * view while the async function to update the object remains active.
+     */
+    update: (id: any, entityValue: any) => Observable<any>;
+}
+/**
+ * Prototype of the function that will be used instead of HttpClient for
+ * CRUD operations.
+ * @param op - the CRUD operation being requested
+ * @param entityValue - The entity or entity value upon which the operation
+ * is being requested. for 'create' & 'update' this will be the value
+ * of the reactive form. This is typically form.value or the 2nd arg to create
+ * & update methods of SPMatEntityCrudCreateEditBridge.
+ */
+type CRUD_OP_FN<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> = (op: string, id: TEntity[IdKey] | undefined, // valid only for 'get', 'update' & 'delete'
+entityValue: any, // valid only for 'create' & 'update'
+entityCrudComponent: any) => Observable<TEntity | null>;
+type ALLOW_ITEM_ACTION_FN<TEntity> = (entity: TEntity, action: string) => boolean;
+/**
+ * This interface is used to define sub types for the "New {{item}}" button on
+ * top of the CRUD UI. An array of these is provided as the value to the
+ * component property 'newItemSubTypes'.
+ */
+interface NewItemSubType {
+    /**
+     * A role string that will be passed as argument to the (action) event
+     * handler. This string allows the event handler to distinguish the selected
+     * sub-type.
+     *
+     * The special keyword '_new_' can be used to activate the
+     * `createEditTemplate` template if one is provided. In this case the params
+     * element value (see below) can be used in the template to distinguish
+     * between different menu items.
+     */
+    role: string;
+    /**
+     * Label displayed in the menu representing this role.
+     */
+    label: string;
+    /**
+     * Arbitrary value that will be passed to the 'createEditTemplate' in the
+     * $implicit template context as 'params'. You can access this in the
+     * template like below (see `data.params`):-
+        ```
+        <ng-template #createEdit let-data>
+          <app-create-edit-entity-demo
+            [bridge]="data.bridge"
+            [entity]="data.entity"
+            [params]="data.params"
+          ></app-create-edit-entity-demo>
+        </ng-template>
+        ```
+  
+      If params is an object and it includes the key 'title', its value will be
+      used as the title for the edit form.
+     */
+    params?: any;
+}
+type CrudOp = 'create' | 'retrieve' | 'update' | 'delete' | undefined;
+interface SPMatEntityCrudHttpContext {
+    entityName: string;
+    entityNamePlural: string;
+    endpoint: string;
+    op: CrudOp;
+}
+declare const SP_MAT_ENTITY_CRUD_HTTP_CONTEXT: HttpContextToken<SPMatEntityCrudHttpContext>;
+
+declare const SP_MAT_ENTITY_CRUD_CONFIG: InjectionToken<SPMatEntityCrudConfig>;
+
+type HttpContextInput = [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any] | HttpContext;
+/**
+ * Converts array of HttpContextToken key, value pairs to HttpContext
+ * object in argument 'context'.
+ * @param context HTTP context to which the key, value pairs are added
+ * @param reqContext HttpContextToken key, value pairs array
+ * @returns HttpContext object, with the key, value pairs added. This is
+ * the same object as the 'context' argument.
+ */
+declare function convertHttpContextInputToHttpContext(context: HttpContext, reqContext: HttpContextInput): HttpContext;
+
+/**
+ * Describes an action on an item in the MatEntityCrud component. Actions are
+ * shown in the context menu for each entity in the MatEntityCrud component.
+ * The action is triggered when the user selects the corresponding menu item.
+ * There are two ways to handle the action when it is triggered (user selects
+ * the corresponding menu item):
+ *
+ * 1. If the action's 'role' property is one of the predefined roles
+ *   ('_edit_', '_view_', '_delete_'), the MatEntityCrud component handles
+ *   the action internally by opening the corresponding dialog (edit/view)
+ *   or performing the delete operation.
+ * 2. If the action maps to a HTTP REST API endpoint on the item at the server,
+ *   the MatEntityCrud component can perform the HTTP request. To enable this,
+ *   the application must set the action's 'behavior' property to 'http' and
+ *   if the REST request differs from the default POST to the entity's base URL
+ *   with the action's 'role' appended as the URL path, provide the necessary
+ *   HTTP request parameters in the 'httpRequestParameters' property.
+ * 3. For all other actions, the MatEntityCrud component emits an 'action'
+ *   event with the action's 'role' and the entity as arguments. The
+ *   application can listen to this event and handle the action as needed.
+ *
+ * @template TEntity The type of the entity on which the action is performed.
+ */
+interface MatEntityCrudItemAction<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> extends SPContextMenuItem {
+    /**
+     * Optional confirmation prompt message to be shown to the user
+     * before performing the action. If specified, the user must confirm
+     * the action before it is executed.
+     */
+    confirmPrompt?: string;
+    /**
+     * Optional message to be shown to the user after the action is
+     * successfully performed.
+     */
+    successMessage?: string;
+    /**
+     * Optional error message to be shown to the user if the action fails.
+     */
+    errorMessage?: string;
+    /**
+     * HTTP request parameters for actions that map to HTTP REST API
+     * endpoints on the item at the server. This property is used when
+     * 'actionBehavior' is set to 'http'.
+     *
+     * If not specified, and behavior is set to 'http', a POST request is
+     * made to the entity's base URL with the action's 'role' appended
+     * as the URL path.
+     */
+    httpRequestParameters?: {
+        method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+        urlPath?: string;
+        params?: HttpParams;
+        body?: any;
+    };
+    /**
+     * Custom handler function to be called when the action is triggered.
+     * If provided, this function is called instead of the default handling
+     * by the MatEntityCrud component. This property takes precedence over
+     * `httpRequestParameters`.
+     *
+     * @param entity The entity on which the action is performed.
+     */
+    action?: (entity: TEntity) => void;
+}
+
+/**
+ * This is a convenience base class that clients can derive from to implement
+ * their CRUD form component. Particularly this class registers the change
+ * detection hook which will be called when the user attempts to close the
+ * form's parent container pane via the Close button on the top right.
+ *
+ * This button behaves like a Cancel button in a desktop app and therefore if
+ * the user has entered any data in the form's controls, (determined by
+ * checking form.touched), then a 'Lose Changes' prompt is displayed allowing
+ * the user to cancel the closure.
+ *
+ * The `@Component` decorator is fake to keep the VSCode angular linter quiet.
+ *
+ * This class can be used in two modes:
+ *
+ *  I. SPMatEntityCrudComponent mode
+ *     This mode relies on a bridge interface that implements the
+ *     SPMatEntityCrudCreateEditBridge interface to perform the entity
+ *     load/create/update operations. This is the intended mode when the
+ *     component is used as a part of the SPMatEntityCrudComponent to
+ *     create/update an entity. This mode requires the following properties
+ *     to be set:
+ *       - entity: TEntity | TEntity[IdKey] | undefined (for create)
+ *       - bridge: SPMatEntityCrudCreateEditBridge
+ *
+ *  II. Standalone mode
+ *     This mode does not rely on the bridge interface and the component
+ *     itself performs the entity load/create/update operations. However, if
+ *     the `bridge` input is set, then it will be used to close the create/edit
+ *     form pane when create/update is successful.
+ *
+ *     This mode requires the following properties to be set:
+ *      - entity: TEntity | TEntity[IdKey] | undefined (for create)
+ *      - baseUrl: string - Base URL for CRUD operations. This URL does not
+ *        include the entity id. The entity id will be appended to this URL
+ *        for entity load and update operations. For create operation, this
+ *        URL is used as is.
+ *      - entityName: string - Name of the entity, used to parse sideloaded
+ *        entity responses.
+ *      - httpReqContext?: HttpContextInput - Optional HTTP context to be
+ *        passed to the HTTP requests. For instance, if your app has a HTTP
+ *        interceptor that adds authentication tokens to the requests based
+ *        on a HttpContextToken, then you can pass that token here.
+ *
+ * I. SPMatEntityCrudComponent mode:
+ *
+ *  1. Declare a FormGroup<> type as
+ *
+ *      ```
+ *      type MyForm = FormGroup<{
+ *        name: FormControl<string>;
+ *        type: FormControl<string>;
+ *        notes: FormControl<string>;
+ *      }>;
+ *      ```
+ *
+ *  2. Derive your form's component class from this and implement the
+ *    createForm() method returing the FormGroup<> instance that matches
+ *    the FormGroup concrete type above.
+ *
+ *      ```
+ *      class MyFormComponent extends SPMatEntityCrudFormBase<MyForm, MyEntity> {
+ *        constructor() {
+ *          super()
+ *        }
+ *        createForm() {
+ *          return new FormGroup([...])
+ *        }
+ *      }
+ *      ```
+ *
+ *  3. If your form's value requires manipulation before being sent to the
+ *    server, override `getFormValue()` method and do it there before returning
+ *    the modified values.
+ *
+ *  4. Wire up the form in the template as below
+ *
+ *      ```html
+ *      @if (loadEntity$ | async) {
+ *      <form [formGroup]='form'.. (ngSubmit)="onSubmit()">
+ *        <button type="submit">Submit</button>
+ *      </form>
+ *      } @else {
+ *        <div>Loading...</div>
+ *      }
+ *      ```
+ *
+ *     Here `loadEntity$` is an Observable<boolean> that upon emission of `true`
+ *     indicates that the entity has been loaded from server (in case of edit)
+ *     and the form is ready to be displayed. Note that if the full entity was
+ *     passed in the `entity` input property, then no server load is necessary
+ *     and the form will be created immediately.
+ *
+ *  5. In the parent component that hosts the SPMatEntityCrudComponent, set
+ *     the `entity` and `bridge` input properties of this component to
+ *     appropriate values. For instance, if your form component has the
+ *     selector `app-my-entity-form`, then the parent component's template
+ *     will have:
+ *
+ *    ```html
+ *   <sp-mat-entity-crud
+ *    ...
+ *    createEditFormTemplate="entityFormTemplate"
+ *   ></sp-mat-entity-crud>
+ *   <ng-template #entityFormTemplate let-data="data">
+ *    <app-my-entity-form
+ *      [entity]="data.entity"
+ *      [bridge]="data.bridge"
+ *    ></app-my-entity-form>
+ *   </ng-template>
+ *  ```
+ *
+ *  II. Standalone mode
+ *
+ * 1..4. Same as above, except set the required `bridge` input to `undefined`.
+ * 5. Initialize the component's inputs `baseUrl` and `entityName` with the
+ *    appropriate values. If you would like to pass additional HTTP context to
+ *    the HTTP requests, then set the `httpReqContext` input as well.
+ *    If the entity uses an id key other than 'id', then set the `idKey` input
+ *    to the appropriate id key name.
+ * 6. If you want to retrieve the created/updated entity after the create/update
+ *    operation, override the `onPostCreate()` and/or `onPostUpdate()` methods
+ *    respectively.
+ */
+declare abstract class SPMatEntityCrudFormBase<TFormGroup extends AbstractControl, TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit, OnDestroy {
+    entity: _angular_core.InputSignal<TEntity | TEntity[IdKey] | undefined>;
+    bridge: _angular_core.InputSignal<SPMatEntityCrudCreateEditBridge | undefined>;
+    params: _angular_core.InputSignal<any>;
+    entityName: _angular_core.InputSignal<string | undefined>;
+    baseUrl: _angular_core.InputSignal<string | undefined>;
+    httpReqContext: _angular_core.InputSignal<HttpContextInput | undefined>;
+    idKey: _angular_core.InputSignal<string>;
+    loadEntity$: Observable<boolean>;
+    loadResponse: _angular_core.WritableSignal<any>;
+    _entity: _angular_core.WritableSignal<TEntity | undefined>;
+    sub$: Subscription;
+    _form: _angular_core.WritableSignal<TFormGroup | undefined>;
+    form: _angular_core.Signal<TFormGroup>;
+    transloco: TranslocoService;
+    cdr: ChangeDetectorRef;
+    http: HttpClient;
+    canCancelEdit: () => boolean;
+    _canCancelEdit(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Additional parameters for loading the entity, in case this.entity() value
+     * is of type TEntity[IdKey].
+     * @returns
+     */
+    getLoadEntityParams(): string | HttpParams;
+    /**
+     * Returns true if the entity needs to be loaded from server. The default
+     * implementation returns true if the `entity` parameter is not an object,
+     * indicating that it's of type 'TEntity[IdKey]' or is undefined. Derived
+     * classes can override this method to provide custom logic.
+     * @param entityOrId
+     * @returns Whether the entity needs to be loaded from server.
+     */
+    loadEntityRequired(entityOrId: TEntity | TEntity[IdKey] | undefined): boolean | undefined;
+    /**
+     * Return the TEntity object from the response returned by the
+     * load() method. Typically entity load returns the actual
+     * entity object itself. In some cases, where response is sideloaded, the
+     * default implementation here uses the `sideloadToComposite()` utility to
+     * extract the entity from the response after merging (inplace) the
+     * sideloaded data into a composite.
+     *
+     * If you have a different response shape, or if your sideloaded object
+     * response requires custom custom `sideloadDataMap`, override this method
+     * and implement your custom logic to extract the TEntity object from the
+     * response.
+     * @param resp
+     * @returns
+     */
+    getEntityFromLoadResponse(resp: any): TEntity | undefined;
+    /**
+     * Create the TFormGroup FormGroup class that will be used for the reactive
+     * form.
+     * @param entity
+     */
+    abstract createForm(entity: TEntity | undefined): TFormGroup;
+    /**
+     * Override to customize the id key name if it's not 'id'
+     * @returns The name of the unique identifier key that will be used to
+     * extract the entity's id for UPDATE operation.
+     */
+    getIdKey(): string;
+    getBusyWheelName(): string;
+    /**
+     * Return the form's value to be sent to server as Create/Update CRUD
+     * operation data.
+     * @returns
+     */
+    getFormValue(): any;
+    onSubmit(): void;
+    /**
+     * Reset the form to its initial state. This is a generic implementation
+     * that recursively resets all FormGroup and FormArray controls.
+     */
+    onReset(): void;
+    onPostCreate(entity: TEntity): void;
+    onPostUpdate(entity: TEntity): void;
+    /**
+     * Loads the entity if `this.entity()` is of type TEntity[IdKey]. If `bridge`
+     * input is defined, then it's `loadEntity()` method is used to load the
+     * entity. Otherwise, then this method attempts to load the entity using
+     * HTTP GET from the URL derived from `baseUrl` input.
+     * @param entityOrId Can be full entity or just the entity id.
+     * @returns
+     */
+    load(entityOrId: any): Observable<TEntity>;
+    /**
+     * Loads the entity using HTTP GET from the URL derived from `baseUrl` input.
+     */
+    protected loadEntity(entityId: any): Observable<TEntity>;
+    /**
+     * Create a new entity using the bridge if defined, otherwise using HTTP
+     * POST to the `baseUrl`.
+     * @param values
+     * @returns
+     */
+    protected create(values: any): Observable<TEntity>;
+    protected createEntity(values: any): Observable<TEntity>;
+    /**
+     * Update an existing entity using the bridge if defined, otherwise using HTTP
+     * PATCH to the URL derived from `baseUrl` and the entity id.
+     * @param id
+     * @param values
+     * @returns
+     */
+    protected update(id: any, values: any): Observable<TEntity>;
+    protected updateEntity(id: any, values: any): Observable<TEntity>;
+    /**
+     * Override to get the standalone mode indicator. Standalone mode is
+     * when both `baseUrl` and `entityName` inputs are defined. This is indication
+     * that the component should perform the CRUD operations itself instead
+     * of relying on the `bridge` input.
+     * @returns
+     */
+    protected getStandaloneMode(): boolean;
+    /**
+     * Wrapper around entityName input to get the entity name. If `bridge` input
+     * is defined, then its `getEntityName()` method is used. This allows
+     * derived classes to override this method to provide custom logic to
+     * determine the entity name.
+     * @returns
+     */
+    protected getEntityName(): string | undefined;
+    /**
+     * Returns the baseUrl. Derived classes can override this to provide custom
+     * logic to determine the baseUrl.
+     * @returns
+     */
+    protected getBaseUrl(): string | undefined;
+    /**
+     * Returns the entity URL for the given entity id. If `bridge` input is
+     * defined, then its `getEntityUrl()` method is used. Otherwise, the URL is
+     * derived from `baseUrl` input.
+     * @param entityId
+     * @returns
+     */
+    protected getEntityUrl(entityId: any): string;
+    protected getRequestContext(): HttpContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPMatEntityCrudFormBase<any, any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SPMatEntityCrudFormBase<any, any, any>, "_#_sp-mat-entity-crud-form-base_#_", never, { "entity": { "alias": "entity"; "required": false; "isSignal": true; }; "bridge": { "alias": "bridge"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "entityName": { "alias": "entityName"; "required": false; "isSignal": true; }; "baseUrl": { "alias": "baseUrl"; "required": false; "isSignal": true; }; "httpReqContext": { "alias": "httpReqContext"; "required": false; "isSignal": true; }; "idKey": { "alias": "idKey"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * SPMatEntityCrudCreateEditBridge implementer uses this interface to
+ * communicate with the parent SPMatEntityCreateComponent. The bridge
+ * component would use the hideCreateEdit() to close itself, when user cancels
+ * the create/edit operation.
+ */
+interface SPMatEntityCrudComponentBase<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> {
+    /**
+     * Wrappers around entityName & entityNamePlural properties.
+     */
+    getEntityName(): string;
+    getEntityNamePlural(): string;
+    /**
+     * Wrapper around idKey property.
+     */
+    getIdKey(): string;
+    /**
+     * This method should return the entity URL for the given entity id.
+     * The entity URL should include any additional query parameters that were
+     * passed to the SPMatEntityCrudComponentBase component's `url` property.
+     * @param id
+     */
+    getEntityUrl(id: TEntity[IdKey] | undefined): string;
+    /**
+     * FormViewHostComponent will call this to close the Create/Edit pane.
+     * SPMatEntityCrudComponentBase implementor will destroy the client form
+     * view and hide the Create/Edit form view pane and show the hidden
+     * entity list view.
+     * @returns
+     */
+    closeCreateEdit: (cancelled: boolean) => void;
+    /**
+     * Used internally by FormViewHostComponent to determine if the client form
+     * view wants to intercept user's cancel the create/edit operation. Perhaps
+     * with the Yes/No prompt 'Lose changes?'
+     * @returns boolean indicating it's okay to cancel the create/edit operation.
+     */
+    canCancelEdit: () => boolean;
+    /**
+     * Client form view can register a callback that will be invoked by the
+     * framework when user cancels the create/edit operation by clicking on the
+     * close button on the top right.
+     * @param callback
+     * @returns
+     */
+    registerCanCancelEditCallback: (callback: () => boolean) => void;
+    /**
+     * Initiates update on the given entity.
+     * @returns
+     */
+    triggerEntityUpdate: (entity: TEntity) => void;
+    /**
+     * Initiates entity delete.
+     * @returns
+     */
+    triggerEntityDelete: (entity: TEntity) => void;
+    /**
+     * Called by client form-view host component to close a new entity.
+     * @param entityValue The ReactiveForm.value object that the server expects
+     * to create a new object.
+     * @returns The new Entity object returned by the server. For typical REST
+     * API, this would be of the same shape as the objects returned by the
+     * REST's GET request.
+     */
+    create: (entityValue: any) => Observable<any>;
+    /**
+     * Called by client form-view host component to close a new entity.
+     * @param id The id of the entity being edited.
+     * @param entityValue The ReactiveForm.value object that the server expects
+     * to update the new object.
+     * @returns The new Entity object returned by the server. For typical REST
+     * API, this would be of the same shape as the objects returned by the
+     * REST's GET request.
+     */
+    update: (id: any, entityValue: any) => Observable<any>;
+    /**
+     * Close the preview pane.
+     * @returns
+     */
+    closePreview: () => void;
+    /**
+     * Returns the context menu items for the entity. This can be used to build
+     * the context menu for an entity in its preview pane toolbar.
+     * @returns
+     */
+    getItemActions(entity?: TEntity): SPContextMenuItem[];
+    /**
+     * Returns the class to be used for the preview pane content. This interface
+     * is provided to allow the PreviewPaneComponent to access the client
+     * configured class for the preview pane content.
+     */
+    getPreviewPaneContentClass(): string;
+    getFormPaneWrapperClass(): string;
+    getFormPaneContentClass(): string;
+    getItemLabel(): string | Observable<string>;
+    getItemLabelPlural(): string | Observable<string>;
+    removeEntity(id: TEntity[IdKey]): void;
+    /**
+     * Update the entity with the given id in the list of entities.
+     * This is typically called by the client when it has performed an update
+     * on the entity itself and want to reflect the resulting changed
+     * entity in the list view.
+     *
+     * @param id The id of the entity to update.
+     * @param data The updated entity.
+     */
+    updateEntity(id: TEntity[IdKey], data: TEntity): void;
+    /**
+     * Perform a custom action on the entity endpoint. The action is specified
+     * by the verb argument, which will be used to derive the final URL. This
+     * is keeping in line with DRF specification where viewsets can define
+     * custom action methods, which translate into endpoints with the same name
+     * ast he action method.
+     * @param id id of the entity to perform the action on.
+     * @param verb The action verb, which will be appended to the entity URL to
+     * derive the final URL for the POST request.
+     * @param addlParams additional query parameters to include in the request.
+     * Called `additional` as these are in addition to the query params specified
+     * in the CRUD's endpoint.
+     * @param data the data to send with the request for the POST
+     * @returns Observable<TEntity>
+     */
+    doEntityAction(id: TEntity[IdKey], verb: string, addlParams: HttpParams, data: any, busyWheelName: string): Observable<any>;
+}
+
+/**
+ * A preview pane container to provide a consistent UX for all preview panes.
+ * It consits of a toolbar on the top and a container div below that takes up
+ * the rest of the preview pane area.
+ */
+declare class SPMatEntityCrudPreviewPaneComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit, OnDestroy {
+    entity: InputSignal<TEntity>;
+    entityCrudComponent: InputSignal<SPMatEntityCrudComponentBase<TEntity, IdKey>>;
+    title: InputSignal<string | undefined>;
+    disableUpdate: InputSignal<boolean>;
+    hideUpdate: InputSignal<boolean>;
+    disableDelete: InputSignal<boolean>;
+    hideDelete: InputSignal<boolean>;
+    itemActions: SPContextMenuItem[];
+    _disableActionFactory: (role: string, signal?: InputSignal<boolean>) => _angular_core.Signal<boolean>;
+    _disableUpdate: _angular_core.Signal<boolean>;
+    _disableDelete: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onEdit(): void;
+    onDelete(): void;
+    onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPMatEntityCrudPreviewPaneComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SPMatEntityCrudPreviewPaneComponent<any, any>, "sp-mat-entity-crud-preview-pane", never, { "entity": { "alias": "entity"; "required": true; "isSignal": true; }; "entityCrudComponent": { "alias": "entityCrudComponent"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "disableUpdate": { "alias": "disableUpdate"; "required": false; "isSignal": true; }; "hideUpdate": { "alias": "hideUpdate"; "required": false; "isSignal": true; }; "disableDelete": { "alias": "disableDelete"; "required": false; "isSignal": true; }; "hideDelete": { "alias": "hideDelete"; "required": false; "isSignal": true; }; }, {}, never, ["[previewToolbarContent]", "[previewContent]"], true, never>;
+}
+
+declare class FormViewHostComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements SPMatEntityCrudCreateEditBridge, OnInit, OnDestroy {
+    entityCrudComponentBase: _angular_core.InputSignal<SPMatEntityCrudComponentBase<TEntity, IdKey>>;
+    clientViewTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    _itemLabel: _angular_core.Signal<Observable<string>>;
+    _itemLabelPlural: _angular_core.Signal<Observable<string>>;
+    entity: _angular_core.WritableSignal<TEntity | undefined>;
+    title: _angular_core.WritableSignal<Observable<string> | undefined>;
+    params: _angular_core.WritableSignal<any>;
+    clientFormView: EmbeddedViewRef<any> | null;
+    vc: _angular_core.Signal<ViewContainerRef | undefined>;
+    config: SPMatEntityCrudConfig;
+    sub$: Subscription;
+    transloco: TranslocoService;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    show(entity: TEntity | undefined, params?: any): void;
+    getEntityName(): string;
+    getIdKey(): string;
+    getEntityUrl(entityId: any): string;
+    close(cancel: boolean): void;
+    registerCanCancelEditCallback(callback: () => boolean): void;
+    create(entityValue: any): Observable<any>;
+    update(id: any, entityValue: any): Observable<any>;
+    /**
+     * Creates the client view provided via template
+     */
+    createClientView(): void;
+    destroyClientView(): void;
+    onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormViewHostComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormViewHostComponent<any, any>, "sp-create-edit-entity-host", never, { "entityCrudComponentBase": { "alias": "entityCrudComponentBase"; "required": true; "isSignal": true; }; "clientViewTemplate": { "alias": "clientViewTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PreviewHostComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit, OnDestroy {
+    vc: _angular_core.Signal<ViewContainerRef | undefined>;
+    entityCrudComponentBase: _angular_core.InputSignal<SPMatEntityCrudComponentBase<TEntity, IdKey>>;
+    clientViewTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    entity: _angular_core.WritableSignal<TEntity | undefined>;
+    clientView: EmbeddedViewRef<any> | null;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    show(entity: TEntity | undefined, params?: any): void;
+    close(): void;
+    private createClientView;
+    destroyClientView(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PreviewHostComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PreviewHostComponent<any, any>, "sp-entity-crud-preview-host", never, { "entityCrudComponentBase": { "alias": "entityCrudComponentBase"; "required": true; "isSignal": true; }; "clientViewTemplate": { "alias": "clientViewTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SPMatEntityCrudComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> extends SPMatEntityListComponent<TEntity, IdKey> implements SPMatEntityCrudComponentBase<TEntity, IdKey> {
+    private snackBar;
+    itemLabel: _angular_core.InputSignal<string | Observable<string> | undefined>;
+    itemLabelPlural: _angular_core.InputSignal<string | Observable<string> | undefined>;
+    /**
+     * Title string displayed above the component. If not specified, will use
+     * itemLabelPlural() as the title.
+     */
+    title: _angular_core.InputSignal<string | Observable<string> | undefined>;
+    /**
+     *
+     */
+    itemActions: _angular_core.InputSignal<MatEntityCrudItemAction<TEntity, IdKey>[]>;
+    /**
+     * Specify the list of router paths that will be set as the value for
+     * [routerLink] for the 'New {{ item }}' button. If not specified,
+     * if createEditTemplate is specified, it will be shown. If not, `action`
+     * out event will be raised with `{ role: '_new_' }`.
+     */
+    newItemLink: _angular_core.InputSignal<string | string[] | undefined>;
+    /**
+     * If not specified, will default to 'New <itemLabel()>'.
+     */
+    newItemLabel: _angular_core.InputSignal<string | string[] | undefined>;
+    /**
+     * Text for the Edit <item> pane title
+     */
+    editItemTitle: _angular_core.InputSignal<string | undefined>;
+    /**
+     * If you want "New {{item}}" button to support multiple entity types,
+     * you can set this to `NewItemSubType[]`, where each element stands for for
+     * a dropdown menu item. Refer to `NewItemSubType` for details on this
+     * interface.
+     */
+    newItemSubTypes: _angular_core.InputSignal<NewItemSubType[] | undefined>;
+    /**
+     * If you want to take control of the network operations for the CRUD
+     * operations (GET/CREATE/UPDATE/DELETE), provide a value for this property.
+     */
+    crudOpFn: _angular_core.InputSignal<CRUD_OP_FN<TEntity, IdKey> | undefined>;
+    /**
+     * Item preview template.
+     */
+    previewTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * Whether to allow a context menu action or not. Return false to disable
+     * the action.
+     */
+    allowEntityActionFn: _angular_core.InputSignal<ALLOW_ITEM_ACTION_FN<TEntity> | undefined>;
+    /**
+     * A template that allows the header to be replaced. Usage:-
+     *
+     *    ```
+     *    <sp-map-entity-crud
+     *      [headerTemplate]="myCrudViewHeader"
+     *    ></sp-map-entity-crud>
+     *    <ng-template #myCrudViewHeader>...</ng-template>
+     *    ```
+     */
+    headerTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * Set this to the custom template identifier that will replace the
+     * "New {{Item}}" button portion. This template will expand towards the
+     * title which will be placed to its left (right in rtl).
+     *
+     *    ```
+     *    <sp-map-entity-crud
+     *      [actionsTemplate]="myCrudActions"
+     *    ></sp-map-entity-crud>
+     *    <ng-template #myCrudActions>...</ng-template>
+     *    ```
+     */
+    actionsTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * CRUD action response parser. This will be called with the response
+     * from CREATE & UPDATE operations to parse the response JSON and return
+     * the created/updated TEntity.
+     */
+    crudResponseParser: _angular_core.InputSignal<SPMatEntityCrudResponseParser | undefined>;
+    /**
+     * An ng-template name that contains the component which provides the
+     * create/edit CRUD action.
+     *
+     *  ```
+     *  <ng-template #createEdit let-data>
+     *    <app-create-edit-entity-demo [bridge]="data.bridge" [entity]="data.entity"></app-create-edit-entity-demo>
+     *  </ng-template>
+     *  ```
+     * Note how [bridge] & [entity] properties are set deriving them from the
+     * implicit template context. [entity] will be undefined for Create
+     * opreation and will be the valid entity for an Update.
+     * (app-create-edit-entity-demo here is the client code that implements the
+     * Create/Edit form)
+     */
+    createEditFormTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    /**
+     * Disables the per item actions column, preventing 'Edit' & 'Delete'
+     * (and other user defined) item operations.
+     */
+    disableItemActions: _angular_core.InputSignal<boolean>;
+    /**
+     * Disables the Create function.
+     */
+    disableCreate: _angular_core.InputSignal<boolean>;
+    /**
+     * View refresh policy after a CREATE/UPDATE operation. Values
+     *  'none'   - Objects are not refreshed after an edit operation. The return
+     *             value of the edit operation is used as the object to
+     *             add/update the component's internal store. This is the default.
+     *  'object' - Refresh just the object that was returned from the
+     *             CREATE/UPDATE operation. Use this if the JSON object returned
+     *             after a successful CREATE/UPDATE op differs from the JSON
+     *             object returned for the GET request.
+     *  'all'    - Refresh the entire list after a CREATE/UPDATE operation. This
+     *             mimics the behaviour of legacy HTML apps with pure server
+     *             defined UI.
+     */
+    refreshAfterEdit: _angular_core.InputSignal<"object" | "none" | "all">;
+    /**
+     * HttpContext for crud requests - `create`, `retrieve`, `update` & `delete`.
+     * Note that HttpContext for `list` operation should be set using the
+     * `httpReqContext` property inherited from SPMatEntityListComponent.
+     * The value of the property is an object where the key names reflect the CRUD
+     * operation with each of these keys expected to have a value of type
+     * `[[HttpContextToken<any>, any]] | [HttpContextToken<any>, any] | HttpContext`.
+     *
+     * Alternatively the property value can be set to
+     * `[[HttpContextToken<any>, any]] | [HttpContextToken<any>, any] | HttpContext`,
+     * in which case the same context would be used for all HTTP requests.
+     */
+    crudHttpReqContext: _angular_core.InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | {
+        create?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        retrieve?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        update?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        delete?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+    } | undefined>;
+    /**
+     * Width of the edit pane as a percentange of the overall <as-split> width.
+     */
+    editPaneWidth: _angular_core.InputSignal<number>;
+    /**
+     * Width of the preview pane as a percentange of the overall <as-split> width.
+     */
+    previewPaneWidth: _angular_core.InputSignal<number>;
+    /**
+     * The class class that will be applied to the list pane wrapper.
+     */
+    listPaneWrapperClass: _angular_core.InputSignal<string>;
+    /**
+     * The class class that will be applied to the preview pane wrapper.
+     * Inside this wrapper, another div element with class='previewPaneContentClass()'
+     * will be created to host the preview content. The client supplied preview
+     * template will be rendered inside this div.
+     *
+     * +----------------------------------------+
+     * | previewPaneWrapperClass                |
+     * |----------------------------------------|
+     * | preview toolbar                        |
+     * |----------------------------------------|
+     * | +------------------------------------+ |
+     * | | div class=previewPaneContentClass()| |
+     * | |------------------------------------| |
+     * | | client supplied preview template   | |
+     * | +------------------------------------+ |
+     * +----------------------------------------+
+     */
+    previewPaneWrapperClass: _angular_core.InputSignal<string>;
+    /**
+     * The class class that will be applied to the preview pane content.
+     */
+    previewPaneContentClass: _angular_core.InputSignal<string>;
+    /**
+     * The class class that will be applied to the form pane wrapper. Inside this
+     * wrapper, another div element with class='formPaneContentClass()' will be
+     * created to host the form content. The client supplied form template will
+     * be rendered inside this div.
+     *
+     * +----------------------------------------+
+     * | formPaneWrapperClass                   |
+     * | +------------------------------------+ |
+     * | | div class=formPaneContentClass()   | |
+     * | |------------------------------------| |
+     * | | form title + close button          | |
+     * | |------------------------------------| |
+     * | | client supplied form template      | |
+     * | +------------------------------------+ |
+     * +----------------------------------------+
+     */
+    formPaneWrapperClass: _angular_core.InputSignal<string>;
+    /**
+     * The CSS class that will be applied to the form pane content.
+     */
+    formPaneContentClass: _angular_core.InputSignal<string>;
+    private getLabel;
+    _itemLabel: _angular_core.Signal<Observable<string>>;
+    _itemLabelPlural: _angular_core.Signal<Observable<string>>;
+    _title: _angular_core.Signal<Observable<string | undefined>>;
+    _endpointSansParams: _angular_core.Signal<string>;
+    _endpointParams: _angular_core.Signal<void>;
+    componentColumns: _angular_core.Signal<readonly MatColumnDef[]>;
+    _clientColumnDefs: QueryList<MatColumnDef>;
+    /**
+     * Event raised for user selecting an item action. It's also raised
+     * for 'New <Item>' action, if 'newItemLink' property is not set.
+     */
+    action: EventEmitter<{
+        role: string;
+        entity?: TEntity;
+    }>;
+    /**
+     * Event raised when create Create/Edit pane is activated & deactivated.
+     * Event contains two flags:-
+     *  activated - whether the createEdit form view was activated or
+     *              deactivated.
+     *  cancelled - whether the form view was cancelled by user. False for this
+     *              indicates that the form view was closed after a successful
+     *              edit operation.
+     */
+    entityViewPaneActivated: EventEmitter<{
+        activated: boolean;
+        cancelled: boolean | undefined;
+        mode: "edit" | "preview";
+    }>;
+    busyWheelId: string;
+    sub$: Subscription;
+    spEntitiesList: _angular_core.Signal<SPMatEntityListComponent<TEntity, IdKey> | undefined>;
+    spEntitiesListInited: _angular_core.EffectRef;
+    crudConfig: SPMatEntityCrudConfig;
+    createEditHostComponent: _angular_core.Signal<FormViewHostComponent<{
+        [x: string]: PropertyKey;
+    }, string> | undefined>;
+    createEditViewActive: _angular_core.WritableSignal<boolean>;
+    canCancelEditCallback: () => boolean;
+    previewHostComponent: _angular_core.Signal<PreviewHostComponent<{
+        [x: string]: PropertyKey;
+    }, string> | undefined>;
+    previewActive: _angular_core.Signal<boolean>;
+    previewedEntity: _angular_core.WritableSignal<TEntity | undefined>;
+    entityPaneActive: _angular_core.Signal<boolean>;
+    entityPaneWidth: _angular_core.Signal<number>;
+    entitiesPaneWidth: _angular_core.Signal<number>;
+    entitiesPaneHidden: _angular_core.Signal<boolean>;
+    defaultItemCrudActions: _angular_core.WritableSignal<MatEntityCrudItemAction<TEntity, IdKey>[]>;
+    columnsWithAction: _angular_core.Signal<(string | _smallpearl_ngx_helper_entity_field.SPEntityFieldSpec<TEntity, IdKey>)[]>;
+    _itemActions: (entity: TEntity) => MatEntityCrudItemAction<TEntity, IdKey>[];
+    visibleColumns: _angular_core.Signal<string[]>;
+    transloco: TranslocoService;
+    constructor(http: HttpClient, snackBar: MatSnackBar, sanitizer: DomSanitizer, injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Override so that we can suppress default action in SPMatEntityListComponent
+     */
+    ngAfterViewInit(): void;
+    /**
+     * If the create/edit entity form is active, it calls its registered
+     * canCancelEdit callback to determine if it's okay to cancel the edit.
+     * You can use this method from the host component's router guard to
+     * ensure that any changes made to the form are not accidentally lost by
+     * navigating away from the CRUD page.
+     *
+     * If your CRUD page has multiple sp-mat-entity-crud components, you have to
+     * implement the logic to call this method on the appropriate component.
+     *
+     * If the the create/edit form is not active, this method returns true.
+     * @returns
+     */
+    canDeactivate(): boolean;
+    refresh(force?: boolean): void;
+    getEntityName(): string;
+    getEntityNamePlural(): string;
+    getIdKey(): string;
+    closeCreateEdit(cancelled: boolean): void;
+    canCancelEdit(): boolean;
+    registerCanCancelEditCallback(callback: () => boolean): void;
+    triggerEntityUpdate(entity: TEntity): void;
+    triggerEntityDelete(entity: TEntity): void;
+    create(entityValue: any): Observable<any>;
+    update(id: TEntity[IdKey], entityValue: any): Observable<any>;
+    /**
+     * Thunk these methods to the internal <sp-mat-entity-list> component.
+     */
+    addEntity(entity: TEntity): void;
+    removeEntity(id: TEntity[IdKey]): void;
+    updateEntity(id: TEntity[IdKey], entity: TEntity): void;
+    /**
+     * Refresh the entity list, after a CRUD CREATE or UPDATE operation.
+     * @param resp This is the response from the CRUD operation (CREATE/UPDATE).
+     * @param method The CRUD operation post which REFRESH is requested.
+     * @returns Observable<TEntity|null>
+     */
+    doRefreshAfterEdit(resp: any, method: 'create' | 'update'): Observable<any>;
+    getCrudOpResponseParser(): SPMatEntityCrudResponseParser;
+    closePreview(): void;
+    private closePreviewImpl;
+    onItemAction(role: string, entity: TEntity): void;
+    onCreate(event: Event): void;
+    onUpdate(entity: TEntity): void;
+    /**
+     * Show the create/edit component. This is deliberately made public so as to
+     * be callable from the client. This allows the client to dynamically
+     * set the form edit template and then show the edit pane by calling this
+     * method.
+     * @param entity
+     * @param params
+     */
+    showCreateEditView(entity?: TEntity | undefined, params?: any): void;
+    showPreviewView(entity?: TEntity, params?: any): void;
+    hidePreviewView(): void;
+    onDelete(entity: TEntity): Promise<void>;
+    getUrl(endpoint: string): string;
+    getEntityUrl(entityId: TEntity[IdKey]): string;
+    getEntityActionUrl(entityId: TEntity[IdKey], action: string): string;
+    handleSelectEntity(entity: TEntity | undefined): void;
+    handleNewItemSubType(subtype: NewItemSubType): void;
+    private getCrudReqHttpContext;
+    isItemActionAllowed(action: string, entity: TEntity): boolean;
+    /**
+     * Returns the list of item actions. Calls 'allowItemActionFn' for each action
+     * to determine if the action is allowed for the given entity.
+     * @returns
+     */
+    getItemActions(entity: TEntity): MatEntityCrudItemAction<TEntity, IdKey>[];
+    getPreviewPaneContentClass(): string;
+    getFormPaneWrapperClass(): string;
+    getFormPaneContentClass(): string;
+    getItemLabel(): string | Observable<string>;
+    getItemLabelPlural(): string | Observable<string>;
+    /**
+     * Perform an action on the entity with the given id. The endpoint for the
+     * action is derived from the `verb` argument which is appended to the
+     * entity URL. This is following DRF specification where ViewSets can be
+     * extended with custom actions that are not part of the standard
+     * CRUD operations. Such methods will have a URL like
+     * `/api/v1/entity/<id>/<verb>/` where `<verb>` is the custom action verb.
+     * @param id
+     * @param verb
+     * @param addlParams
+     * @param data
+     */
+    doEntityAction(id: TEntity[IdKey], verb: string, addlParams: HttpParams, data: any, busyWheelName?: string): Observable<any>;
+    /**
+     * Initialize the columns for the mat-entities-list component. This is
+     * called when the <sp-mat-entities-list> component has been properly
+     * initialized.
+     */
+    private _initEntitiesList;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPMatEntityCrudComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SPMatEntityCrudComponent<any, any>, "sp-mat-entity-crud", never, { "itemLabel": { "alias": "itemLabel"; "required": false; "isSignal": true; }; "itemLabelPlural": { "alias": "itemLabelPlural"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "itemActions": { "alias": "itemActions"; "required": false; "isSignal": true; }; "newItemLink": { "alias": "newItemLink"; "required": false; "isSignal": true; }; "newItemLabel": { "alias": "newItemLabel"; "required": false; "isSignal": true; }; "editItemTitle": { "alias": "editItemTitle"; "required": false; "isSignal": true; }; "newItemSubTypes": { "alias": "newItemSubTypes"; "required": false; "isSignal": true; }; "crudOpFn": { "alias": "crudOpFn"; "required": false; "isSignal": true; }; "previewTemplate": { "alias": "previewTemplate"; "required": false; "isSignal": true; }; "allowEntityActionFn": { "alias": "allowEntityActionFn"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; "crudResponseParser": { "alias": "crudResponseParser"; "required": false; "isSignal": true; }; "createEditFormTemplate": { "alias": "createEditFormTemplate"; "required": false; "isSignal": true; }; "disableItemActions": { "alias": "disableItemActions"; "required": false; "isSignal": true; }; "disableCreate": { "alias": "disableCreate"; "required": false; "isSignal": true; }; "refreshAfterEdit": { "alias": "refreshAfterEdit"; "required": false; "isSignal": true; }; "crudHttpReqContext": { "alias": "crudHttpReqContext"; "required": false; "isSignal": true; }; "editPaneWidth": { "alias": "editPaneWidth"; "required": false; "isSignal": true; }; "previewPaneWidth": { "alias": "previewPaneWidth"; "required": false; "isSignal": true; }; "listPaneWrapperClass": { "alias": "listPaneWrapperClass"; "required": false; "isSignal": true; }; "previewPaneWrapperClass": { "alias": "previewPaneWrapperClass"; "required": false; "isSignal": true; }; "previewPaneContentClass": { "alias": "previewPaneContentClass"; "required": false; "isSignal": true; }; "formPaneWrapperClass": { "alias": "formPaneWrapperClass"; "required": false; "isSignal": true; }; "formPaneContentClass": { "alias": "formPaneContentClass"; "required": false; "isSignal": true; }; }, { "action": "action"; "entityViewPaneActivated": "entityViewPaneActivated"; }, ["_clientColumnDefs"], ["[breadCrumbs]"], true, never>;
+}
+
+export { SPMatEntityCrudComponent, SPMatEntityCrudFormBase, SPMatEntityCrudPreviewPaneComponent, SP_MAT_ENTITY_CRUD_CONFIG, SP_MAT_ENTITY_CRUD_HTTP_CONTEXT, convertHttpContextInputToHttpContext };
+export type { ALLOW_ITEM_ACTION_FN, CRUD_OP_FN, CrudOp, HttpContextInput, MatEntityCrudItemAction, NewItemSubType, SPMatEntityCrudConfig, SPMatEntityCrudCreateEditBridge, SPMatEntityCrudHttpContext, SPMatEntityCrudResponseParser };