@one-paragon/angular-utilities 2.2.6 → 2.2.7

package/table-builder/interfaces/report-def.d.ts

@@ -0,0 +1,229 @@
+import { Dictionary } from './dictionary';
+import { PipeTransform, Predicate, TemplateRef } from '@angular/core';
+import { TableBuilderExport } from '../classes/TableBuilderConfig';
+import { QueryParamsHandling } from '@angular/router';
+import { StylerStyle } from '../../utilities/directives/styler';
+export declare enum FieldType {
+    Unknown = 0,
+    Date = 1,
+    /**
+     * @deprecated If `additional.link` is set the column will be treated as a link.
+     */
+    Link = 2,
+    ImageUrl = 3,
+    Currency = 4,
+    Array = 5,
+    Hidden = 6,
+    Number = 7,
+    String = 8,
+    Boolean = 9,
+    PhoneNumber = 10,
+    /**
+     * @deprecated For mapped properties use proper type (for sorting and filtering) with `map`.
+     * For unmapped properties use `FieldType.NotMapped` with map.
+     */
+    Expression = 11,
+    Enum = 12,
+    DateTime = 13,
+    NotMapped = 14
+}
+export declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+export declare enum Target {
+    Blank = "_blank",
+    Self = "_self",
+    Parent = "_parent",
+    Top = "_top"
+}
+interface BaseMeta<T = any> {
+    displayName?: string;
+    order?: number;
+    preSort?: SortDef;
+    sortLogic?: {
+        /**
+         * defaults to last
+         */
+        nulls?: 'first' | 'last';
+        sortBy?: ((t: T) => any) | 'use map';
+    };
+    noSort?: boolean;
+    width?: string;
+    noExport?: boolean;
+    filterLogic?: {
+        filterBy?: ((t: T) => any) | 'use map';
+        /**
+         * defaults to the MetaData's Field type
+         */
+        filterType?: FieldType;
+    };
+    noFilter?: boolean;
+    customCell?: boolean;
+    /**
+     * @deprecated Use `map`
+     */
+    transform?: ((o: T, ...args: any[]) => any) | ((o: string, ...args: any[]) => any) | PipeTransform;
+    click?: (element: T, key?: string, event?: MouseEvent) => void;
+    template?: TemplateRef<any>;
+    classes?: Dictionary<Predicate<T> | true>;
+    toolTip?: string | ((t: T) => string);
+    useIcon?: boolean;
+    map?: (t: T) => any;
+}
+type Path<T, U = never, P = never> = (T extends P ? never : T extends object ? {
+    [K in keyof T]: K extends string | number ? `${K}` | (T[K] extends (Array<any> | undefined) ? `${K}.${keyof Array<any> & (string | number)}` : `${K}.${Path<T[K], T[K], P | U>}`) : never;
+}[keyof T] : never);
+export interface BaseMappedMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMeta<T> {
+    key: (Path<T> | AdditionalFields[number]) & string;
+    /**
+   * if used with map, `mapItem` will only be used where the row is not available, ex. group header
+   */
+    mapItem?: (i: any) => any;
+}
+export interface MappedMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.String | FieldType.PhoneNumber | FieldType.ImageUrl | FieldType.Link | FieldType.Hidden | FieldType.Unknown;
+    additional?: Additional<T>;
+    mapItem?: (i: string) => any;
+}
+export interface MappedNumberMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.Number | FieldType.Currency;
+    mapItem?: (i: number) => any;
+    additional?: NumberAdditional<T>;
+}
+export interface MappedEnumMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.Enum;
+    mapItem?: (i: number) => any;
+    additional?: EnumAdditional<T>;
+}
+export interface MappedDateMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.Date | FieldType.DateTime;
+    mapItem?: (i: Date) => any;
+    additional?: Additional<T, Date>;
+}
+export interface MappedBooleanMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.Boolean;
+    mapItem?: (i: boolean) => any;
+    additional?: BooleanAdditional<T>;
+}
+export interface MappedArrayMetaData<T = any, AdditionalFields extends string[] = []> extends BaseMappedMetaData<T, AdditionalFields> {
+    fieldType: FieldType.Array;
+    mapItem?: (i: string) => any;
+    additional?: ArrayAdditional<T>;
+}
+export type MetaData<T = any, AdditionalFields extends string[] = []> = MappedMetaData<T, AdditionalFields> | NotMappedMetaData<T> | MappedNumberMetaData<T, AdditionalFields> | MappedEnumMetaData<T, AdditionalFields> | MappedBooleanMetaData<T, AdditionalFields> | MappedDateMetaData<T, AdditionalFields> | MappedArrayMetaData<T, AdditionalFields>;
+export interface NotMappedMetaData<T = any> extends BaseMeta<T> {
+    key: string;
+    fieldType: FieldType.NotMapped | FieldType.Expression;
+    additional?: Additional<T>;
+}
+export interface ReportDef<DataType = any> {
+    data: DataType[];
+    metaData: MetaData[];
+    totalRecords?: number;
+    count: number;
+}
+export interface SortDef {
+    direction: SortDirection;
+    precedence?: number;
+}
+export interface FilterOptions<T = string> {
+    filterableValues: T[];
+}
+export interface DateTimeOptions {
+    format?: string;
+    includeSeconds?: boolean;
+    includeMilliseconds: boolean;
+}
+type interpolatedRoute = string;
+interface BaseAdditional<T = any> {
+    link?: {
+        base?: string;
+        urlKey?: string;
+        target?: Target;
+        useRouterLink?: boolean;
+        /**
+         * If you want to use a route with interpolated params, you can use this. Wrap the property name in curly braces.
+         * For example, if interpolatedRoute = /users/{id}/edit, {id} will be replaced with the value of the element's id property.
+         */
+        interpolatedRoute?: interpolatedRoute | ((t: T) => string);
+        routerLinkOptions?: {
+            queryParams?: [string, interpolatedRoute | ((t: T) => string)][];
+            fragment?: string;
+            preserveFragment?: boolean;
+            queryParamsHandling?: QueryParamsHandling;
+        };
+    };
+    export?: MetaDataExport<T>;
+    dateFormat?: string;
+    dateTimeOptions?: DateTimeOptions;
+    styles?: StylerStyle<T>;
+    columnPartStyles?: {
+        header?: Dictionary<string>;
+        body?: StylerStyle<T>;
+        innerBody?: StylerStyle<T>;
+        footer?: Dictionary<string>;
+    };
+    columnPartClasses?: {
+        header?: Dictionary<Predicate<T> | true>;
+        footer?: Dictionary<Predicate<T> | true>;
+    };
+    footer?: {
+        type: any;
+    };
+}
+export interface Additional<T = any, V = string> extends BaseAdditional<T> {
+    filterOptions?: FilterOptions<V>;
+    footer?: {
+        type: never;
+    };
+}
+interface NumberAdditional<T = any> extends BaseAdditional<T> {
+    filterOptions?: FilterOptions<number>;
+    footer?: {
+        type: 'sum';
+    };
+}
+interface EnumAdditional<T = any> extends BaseAdditional<T> {
+    filterOptions?: FilterOptions<number>;
+    enumMap?: {
+        [key: number]: string;
+    };
+    footer?: {
+        type: never;
+    };
+}
+interface BooleanAdditional<T = any> extends BaseAdditional<T> {
+    filterOptions?: FilterOptions<never>;
+    footer?: {
+        type: never;
+    };
+    boolean?: {
+        showForFalse?: true | {
+            icon: string;
+        };
+        forTrue?: {
+            icon: string;
+        };
+    };
+}
+export declare enum ArrayStyle {
+    CommaDelimited = 0,
+    NewLine = 1
+}
+export interface ArrayAdditional<T = any> extends Additional<T> {
+    limit?: number;
+    arrayStyle?: ArrayStyle;
+}
+interface MetaDataExport<T> extends TableBuilderExport {
+    /**
+     * This will supersede all other mappings when exporting.
+     */
+    mapForExport?: (t: T) => string;
+}
+export declare function metaDataArrToDict<T = MetaData>(arr: MetaData[], transform?: (m: MetaData) => T): Dictionary<T>;
+export interface CustomCellMeta extends Pick<MetaData, 'key' | 'displayName' | 'preSort' | 'fieldType' | 'order' | 'width'> {
+    customCell: true;
+    noExport?: boolean;
+}
+export {};

package/table-builder/ngrx/tableBuilderStateStore.d.ts

@@ -0,0 +1,69 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { Signal } from "@angular/core";
+import { Dictionary } from "../interfaces/dictionary";
+import { PersistedTableState } from "../classes/TableState";
+import * as i0 from "@angular/core";
+export declare class TableBuilderStateStore extends ComponentStore<GlobalStorageState> {
+    constructor();
+    $selectLocalTableProfile: (profileKey: string) => Signal<Profile | undefined>;
+    $selectLocalTableStateForView: (tableId: string) => Signal<PersistedTableState | null>;
+    $selectLocalProfileCurrentKey: (key: string) => Signal<string | undefined>;
+    $selectLocalProfileDefaultKey: (key: string) => Signal<string | undefined>;
+    $selectLocalProfileKeys: (tableId: string) => Signal<string[]>;
+    saveTableSettingsToLocalAndStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    saveTableStateToLocal: (observableOrValue: {
+        tableId: string;
+        tableState: PersistedTableState;
+        stateName?: string;
+        asDefault?: boolean;
+    } | import("rxjs").Observable<{
+        tableId: string;
+        tableState: PersistedTableState;
+        stateName?: string;
+        asDefault?: boolean;
+    }>) => import("rxjs").Subscription;
+    saveTableStateToStorage: (tableId: string, stateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    addNewStateToLocalAndStorage: (tableId: string, newStateName: string, tableState: PersistedTableState, asDefault?: boolean) => void;
+    setLocalCurrentState: (observableOrValue: {
+        tableId: string;
+        currentStateKey: string;
+    } | import("rxjs").Observable<{
+        tableId: string;
+        currentStateKey: string;
+    }>) => import("rxjs").Subscription;
+    setDefaultInLocalAndStorage: (tableId: string, newDefault: string) => void;
+    setDefaultInLocal: (observableOrValue: {
+        key: string;
+        default: string;
+    } | import("rxjs").Observable<{
+        key: string;
+        default: string;
+    }>) => import("rxjs").Subscription;
+    unsetDefaultFromLocalAndStorage: (tableId: string) => void;
+    unsetDefaultFromLocal: (tableId: string) => void;
+    unsetDefaultFromStorage: (tableId: string) => void;
+    setDefaultInStorage: (tableId: string, stateName: string) => void;
+    deleteLocalProfilesState: (observableOrValue: {
+        key: string;
+        stateKey: string;
+    } | import("rxjs").Observable<{
+        key: string;
+        stateKey: string;
+    }>) => import("rxjs").Subscription;
+    deleteProfileFromLocalAndStorage: (key: string, stateKey: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderStateStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableBuilderStateStore>;
+}
+interface PersistedProfile {
+    states: Dictionary<PersistedTableState>;
+    default?: string;
+}
+export interface Profile extends PersistedProfile {
+    current?: string;
+    localSavedState?: PersistedTableState;
+}
+export interface GlobalStorageState {
+    localProfiles: Dictionary<Profile>;
+}
+export declare const defaultStorageState: GlobalStorageState;
+export {};

package/table-builder/pipes/column-total.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { MetaData } from '../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class ColumnTotalPipe implements PipeTransform {
+    transform(data: any[], metaData: MetaData): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnTotalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnTotalPipe, "columnTotal", true>;
+}

package/table-builder/pipes/format-filter-type.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { FilterType } from '../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class FormatFilterTypePipe implements PipeTransform {
+    transform(filterType: FilterType, value: any): "Equals" | "Does Not Equal" | "Greater Than" | "Less Than" | "Between" | "Contains" | "Does Not Contain" | "Start With" | "Ends With" | "Is on" | "Is Not On" | "On or After" | "On or Before" | "Is At" | "Is Not At" | "At or After" | "At or Before" | "Is" | "Is Blank" | "Or" | "And" | "In" | "Custom" | "Is Not Blank";
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFilterTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFilterTypePipe, "formatFilterType", true>;
+}

package/table-builder/pipes/format-filter-value.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { TableStore } from '../classes/table-store';
+import { FilterType } from '../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class FormatFilterValuePipe implements PipeTransform {
+    tableState: TableStore;
+    private datePipe;
+    transform(value: any, key: string, filterType: FilterType): import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFilterValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFilterValuePipe, "formatFilterValue", true>;
+}

package/table-builder/pipes/key-display.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { TableStore } from '../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class KeyDisplayPipe implements PipeTransform {
+    tableState: TableStore;
+    transform: (key: string) => import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyDisplayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeyDisplayPipe, "keyDisplay", true>;
+}

package/table-builder/services/export-to-csv.service.d.ts

@@ -0,0 +1,22 @@
+import { TableStore } from '../classes/table-store';
+import { TableBuilderExport } from '../classes/TableBuilderConfig';
+import { MetaData } from '../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class ExportToCsvService<T> {
+    state: TableStore;
+    private config;
+    private datePipe;
+    $exportSettings: import("@angular/core").Signal<TableBuilderExport & {
+        mapLinkToString?: boolean;
+        excellStyle?: boolean;
+        domainPrefix?: string;
+    }>;
+    exportToCsv: (data: T[]) => void;
+    csvData: (data: Array<T>, metaData: MetaData<T>[]) => string;
+    metaToField: (meta: MetaData<T>, row: T) => any;
+    private stringByType;
+    cleanValForCsv(val: any): any;
+    private transformDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportToCsvService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportToCsvService<any>>;
+}

package/table-builder/services/link-creator.service.d.ts

@@ -0,0 +1,16 @@
+import { MetaData } from "../interfaces/report-def";
+import { Dictionary } from "@ngrx/entity";
+import { QueryParamsHandling } from "@angular/router";
+export declare function createLinkCreatorDict<T>(metaDatas: MetaData<T>[]): Dictionary<LinkInfo>;
+export declare function createLinkCreator<T>(metaData: MetaData<T>): LinkInfo;
+export interface LinkInfo {
+    link: (element: any) => string;
+    target: string;
+    useRouterLink: boolean;
+    routerLinkOptions?: {
+        queryParams: (element: any) => any;
+        fragment?: string;
+        preserveFragment?: boolean;
+        queryParamsHandling?: QueryParamsHandling;
+    };
+}

package/table-builder/services/table-template-service.d.ts

@@ -0,0 +1,14 @@
+import { EnvironmentInjector } from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { MetaData } from "../interfaces/report-def";
+import { InitializationComponent } from "../components/initialization-component/initialization.component";
+import * as i0 from "@angular/core";
+export declare class TableTemplateService {
+    environmentInjector: EnvironmentInjector;
+    tableConfig: import("../classes/TableBuilderConfig").TableBuilderConfig;
+    initConfig: import("@angular/core").ComponentRef<InitializationComponent>;
+    initializationComponentInstance: InitializationComponent;
+    getTemplate(metaData: MetaData): TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableTemplateService>;
+}

package/table-builder/services/transform-creator.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { MetaData } from '../interfaces/report-def';
+import { TableBuilderConfig } from '../classes/TableBuilderConfig';
+export declare function isPipe(o: any): o is PipeTransform;
+export declare function createTransformer(metaData: MetaData<any, any>, config: TableBuilderConfig, noIcons?: boolean, forItem?: boolean): ((value: any, ...args: any[]) => any);
+export declare function createItemTransformer<T = any, AdditionalFields extends string[] = []>(metaData: MetaData<T, AdditionalFields>, config: TableBuilderConfig, noIcons?: boolean, mutate?: boolean): (t: T) => void;
+export declare function createItemTransformers<T = any, AdditionalFields extends string[] = []>(metaDatas: MetaData<T, AdditionalFields>[], config: TableBuilderConfig, noIcons?: boolean, mutate?: boolean): (t: T) => T;
+export declare function dateFormatter(date: string | Date | number, format: string): string | undefined;
+export declare function currencyFormatter(amt: number): string;

package/table-builder/table-builder.module.d.ts

@@ -0,0 +1,14 @@
+import { ModuleWithProviders } from '@angular/core';
+import { TableBuilderConfig } from './classes/TableBuilderConfig';
+import * as i0 from "@angular/core";
+import * as i1 from "./components/table-container/table-container.component";
+import * as i2 from "./directives/custom-cell-directive";
+import * as i3 from "./directives/tb-filter.directive";
+import * as i4 from "./directives/table-wrapper.directive";
+import * as i5 from "../utilities/module";
+export declare class TableBuilderModule {
+    static forRoot(config: TableBuilderConfig): ModuleWithProviders<TableBuilderModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableBuilderModule, never, [typeof i1.TableContainerComponent, typeof i2.CustomCellDirective, typeof i3.TableFilterDirective, typeof i3.TableFilterStringContainsDirective, typeof i4.TableWrapperDirective], [typeof i1.TableContainerComponent, typeof i2.CustomCellDirective, typeof i3.TableFilterStringContainsDirective, typeof i4.TableWrapperDirective, typeof i5.UtilitiesModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableBuilderModule>;
+}

package/utilities/array-helpers.d.ts

@@ -0,0 +1 @@
+export declare const replaceInArrayWithClone: <T = any>(arr: T[], findMeth: (t: T) => boolean, actionOnClone?: (t: T) => any) => T[];

package/utilities/directives/auto-focus.directive.d.ts

@@ -0,0 +1,9 @@
+import { AfterViewInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AutoFocusDirective implements AfterViewInit {
+    private elementRef;
+    autoFocus: boolean;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocusDirective, "[autoFocus]", never, { "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, never, never, true, never>;
+}

package/utilities/directives/clickEmitterDirective.d.ts

@@ -0,0 +1,7 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ClickEmitterDirective extends Subject<boolean> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickEmitterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickEmitterDirective, "[clickEmitter]", ["clickEmitter"], {}, {}, never, never, true, never>;
+}

package/utilities/directives/clickSubject.d.ts

@@ -0,0 +1,9 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ClickSubjectDirective<T = boolean> extends Subject<T> {
+    constructor();
+    _val: T;
+    set clickSubject(val: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickSubjectDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickSubjectDirective<any>, "[clickSubject]", ["clickSubject"], { "clickSubject": { "alias": "clickSubject"; "required": false; }; }, {}, never, never, true, never>;
+}

package/utilities/directives/conditional-classes.directive.d.ts

@@ -0,0 +1,12 @@
+import { Dictionary, Predicate } from '@ngrx/entity';
+import * as i0 from "@angular/core";
+export declare class ConditionalClassesDirective {
+    #private;
+    private el;
+    private renderer;
+    $element: import("@angular/core").InputSignal<any>;
+    $classes: import("@angular/core").InputSignal<Dictionary<true | Predicate<any>> | undefined>;
+    classesApplied: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalClassesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionalClassesDirective, "[conditionalClasses]", never, { "$element": { "alias": "element"; "required": true; "isSignal": true; }; "$classes": { "alias": "conditionalClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/utilities/directives/dialog-service.d.ts

@@ -0,0 +1,10 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class DialogService {
+    allOpenOpDialogs: MatDialogRef<any>[];
+    addDialogRef(ref: MatDialogRef<any>): void;
+    removeDialogRef(ref: MatDialogRef<any>): void;
+    closeAllOpDialogs(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}

package/utilities/directives/dialog.d.ts

@@ -0,0 +1,45 @@
+import { TemplateRef, EventEmitter, Injector, Signal } from '@angular/core';
+import { MatDialogRef, MatDialogConfig } from '@angular/material/dialog';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+interface DialogViewContext<T> {
+    $implicit: T;
+    opDialog: T;
+    close: () => void;
+}
+export declare class DialogWrapper<T = any> {
+    private vcr;
+    viewEmbedded: boolean;
+    viewContext: DialogViewContext<T>;
+    set template(tmpl: TemplateRef<DialogViewContext<T>>);
+    set close(closeMethod: () => void);
+    set data(value: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogWrapper<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogWrapper<any>, "dialog-wrapper", never, {}, {}, never, never, true, never>;
+}
+export declare class DialogDirective<T> {
+    private templateRef;
+    private dialog;
+    private dialogConfig;
+    private service;
+    opDialogClosed: EventEmitter<boolean>;
+    _dialogConfig: MatDialogConfig<T>;
+    opDialogAddDialogClass: boolean;
+    set opDialogConfig(config: MatDialogConfig<T>);
+    get opDialogConfig(): MatDialogConfig<T>;
+    injector: Injector;
+    subscriber: import("../../rxjs").Subscriber;
+    set setControl(i: Observable<T> | Signal<T>);
+    nativeElement?: HTMLElement;
+    dialogRef?: MatDialogRef<any, boolean>;
+    componentWrapper?: DialogWrapper<T>;
+    _data: Subject<Observable<T>>;
+    close(): void;
+    initDialog(): void;
+    setDataAndState: (data: T) => void;
+    setDialogState(open: boolean): void;
+    static ngTemplateContextGuard<T>(dir: DialogDirective<T>, ctx: any): ctx is DialogViewContext<Exclude<T, false | 0 | '' | null | undefined>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDirective<any>, "[opDialog]", never, { "opDialogAddDialogClass": { "alias": "opDialogAddDialogClass"; "required": false; }; "opDialogConfig": { "alias": "opDialogConfig"; "required": false; }; "setControl": { "alias": "opDialog"; "required": false; }; "nativeElement": { "alias": "opDialogOrigin"; "required": false; }; }, { "opDialogClosed": "opDialogClosed"; }, never, never, true, never>;
+}
+export {};

package/utilities/directives/mat-toggle-group-directive.d.ts

@@ -0,0 +1,21 @@
+import { QueryList } from "@angular/core";
+import { MatSlideToggle } from "@angular/material/slide-toggle";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class MatSlideToggleGroupDirective {
+    allowMultiple: boolean;
+    _toggles: QueryList<MatSlideToggle>;
+    set toggles(val: QueryList<MatSlideToggle>);
+    private _ready;
+    get valueEmitter(): Observable<{
+        [key: string]: boolean;
+    }>;
+    getInitValue(): {
+        [k: string]: boolean;
+    };
+    getObs(): Observable<{
+        [k: string]: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSlideToggleGroupDirective, "[opMatSlideToggleGroup]", never, { "allowMultiple": { "alias": "allowMultiple"; "required": false; }; }, { "valueEmitter": "valueEmitter"; }, ["toggles"], never, true, never>;
+}

package/utilities/directives/prevent-enter.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class PreventEnterDirective {
+    onKeyDown(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventEnterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventEnterDirective, "preventEnter", never, {}, {}, never, never, true, never>;
+}

package/utilities/directives/stop-propagation.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class StopPropagationDirective {
+    onClick(event: any): void;
+    onMousedown(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StopPropagationDirective, "[stop-propagation]", never, {}, {}, never, never, true, never>;
+}

package/utilities/directives/styler.d.ts

@@ -0,0 +1,16 @@
+import { Dictionary } from '@ngrx/entity';
+import * as i0 from "@angular/core";
+export declare class StylerDirective {
+    #private;
+    private el;
+    private renderer;
+    $stylesApplied: import("@angular/core").WritableSignal<Dictionary<string>>;
+    $element: import("@angular/core").InputSignal<any>;
+    $styler: import("@angular/core").InputSignal<StylerStyle<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StylerDirective, "[styler]", never, { "$element": { "alias": "element"; "required": true; "isSignal": true; }; "$styler": { "alias": "styler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export type StylerStyle<T = any> = Dictionary<string | {
+    condition?: ((t: T) => boolean) | true;
+    value: ((t: T) => string) | string;
+}>;

package/utilities/directives/trim-whitespace.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class TrimWhitespaceDirective {
+    private elem;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrimWhitespaceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TrimWhitespaceDirective, "input[trimWhitespace]", never, {}, {}, never, never, true, never>;
+}

package/{src/utilities/index.ts → utilities/index.d.ts}

@@ -1,22 +1,15 @@
-export * from './directives/prevent-enter.directive';
-export * from './directives/stop-propagation.directive';
-export * from './directives/auto-focus.directive';
-export * from './directives/clickSubject';
-export * from './directives/clickEmitterDirective';
-export * from './directives/dialog';
-export * from './directives/styler';
-export * from './directives/mat-toggle-group-directive';
-export * from './directives/trim-whitespace.directive';
-
-export * from './pipes/function.pipe';
-export * from './pipes/phone.pipe';
-export * from './pipes/space-case.pipes';
-
-export * from './directives/dialog-service';
-
-export * from './directives/conditional-classes.directive'
-
-
-export * from './module';
-
-
+export * from './directives/prevent-enter.directive';
+export * from './directives/stop-propagation.directive';
+export * from './directives/auto-focus.directive';
+export * from './directives/clickSubject';
+export * from './directives/clickEmitterDirective';
+export * from './directives/dialog';
+export * from './directives/styler';
+export * from './directives/mat-toggle-group-directive';
+export * from './directives/trim-whitespace.directive';
+export * from './pipes/function.pipe';
+export * from './pipes/phone.pipe';
+export * from './pipes/space-case.pipes';
+export * from './directives/dialog-service';
+export * from './directives/conditional-classes.directive';
+export * from './module';