@vality/matez 19.0.1-pr-423-667df70.0

package/lib/components/table/utils/create-unique-column-def.d.ts

@@ -0,0 +1 @@
+export declare function createUniqueColumnDef(name?: unknown): string;

package/lib/components/table/utils/filter-sort.d.ts

@@ -0,0 +1,14 @@
+import { Sort } from '@angular/material/sort';
+import { Observable } from 'rxjs';
+import { NormColumn } from '../types';
+import { ColumnData, DisplayedData, DisplayedDataItem } from '../utils/to-columns-data';
+export type FilterSearchData<T extends object, C extends object> = Map<DisplayedDataItem<T, C>, {
+    byColumns: string[][];
+    byRow: string;
+}>;
+export declare function columnsDataToFilterSearchData<T extends object, C extends object>(src$: Observable<Map<DisplayedDataItem<T, C>, ColumnData>>): Observable<Map<DisplayedDataItem<T, C>, {
+    byColumns: string[][];
+    byRow: string;
+}>>;
+export declare function filterData<T extends object, C extends object>(data: FilterSearchData<T, C>, search: string): DisplayedDataItem<T, C>[];
+export declare function sortData<T extends object, C extends object>(source: DisplayedData<T, C>, data: FilterSearchData<T, C>, columns: NormColumn<T, C>[], sort: Sort): DisplayedData<T, C>;

package/lib/components/table/utils/normalize-string.d.ts

@@ -0,0 +1,2 @@
+export declare const SPACES: RegExp;
+export declare function normalizeString(str: string): string;

package/lib/components/table/utils/table-data-source.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from '@angular/core';
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { TreeData, TreeInlineData, TreeInlineDataItem } from '../tree-data';
+export declare class TableDataSource<T extends object, C extends object = never> extends MatTableDataSource<T | TreeInlineDataItem<T, C>, OnePageTableDataSourcePaginator & MatPaginator> {
+    isTreeData$: BehaviorSubject<boolean>;
+    sourceData$: BehaviorSubject<TreeData<T, C> | T[]>;
+    data$: Observable<T[] | TreeInlineData<T, C>>;
+    get paginator(): OnePageTableDataSourcePaginator & MatPaginator;
+    private __paginator;
+    constructor();
+    setData(data: T[]): void;
+    setTreeData(data: TreeData<T, C>): void;
+}
+declare class OnePageTableDataSourcePaginator implements Partial<MatPaginator> {
+    pageIndex: number;
+    pageSize: number;
+    page: EventEmitter<PageEvent>;
+    initialized: BehaviorSubject<undefined>;
+    get length(): number;
+    set length(_length: number);
+    get displayedPages(): number;
+    private partSize;
+    constructor(partSize?: number);
+    setSize(partSize?: number): void;
+    reload(): void;
+    more(): void;
+    private update;
+}
+export {};

package/lib/components/table/utils/table-to-csv-object.d.ts

@@ -0,0 +1,3 @@
+import { Value } from '../../value';
+import { ColumnData, DisplayedDataItem } from '../utils/to-columns-data';
+export declare function tableToCsvObject<T extends object, C extends object>(cols: Value[], displayedData: Map<DisplayedDataItem<T, C>, ColumnData>): string[][];

package/lib/components/table/utils/to-columns-data.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { Overwrite } from 'utility-types';
+import { Value } from '../../value';
+import { TreeInlineData, TreeInlineDataItem } from '../tree-data';
+import { NormColumn } from '../types';
+export type DisplayedDataItem<T extends object, C extends object> = TreeInlineDataItem<T, C> | T;
+export type DisplayedData<T extends object, C extends object> = TreeInlineData<T, C> | T[];
+export type ColumnDataItem = {
+    value: Value | null;
+    lazyValue?: Observable<Value>;
+    isChild?: boolean;
+    isNextChild?: boolean;
+};
+export type ColumnData = ColumnDataItem[];
+type ScanColumnDataItem = Overwrite<ColumnDataItem, {
+    value: Observable<Value | null>;
+}>;
+type ScanColumnData<T extends object, C extends object> = Map<NormColumn<T, C>, ScanColumnDataItem>;
+type ColumnDataMap<T extends object, C extends object> = Map<DisplayedDataItem<T, C>, ScanColumnData<T, C>>;
+export declare function toObservableColumnsData<T extends object, C extends object>(src$: Observable<{
+    isTree: boolean;
+    data: DisplayedData<T, C>;
+    cols: NormColumn<T, C>[];
+}>): Observable<ColumnDataMap<T, C>>;
+export declare function toColumnsData<T extends object, C extends object>(src$: Observable<ColumnDataMap<T, C>>): Observable<Map<DisplayedDataItem<T, C>, ColumnData>>;
+export {};

package/lib/components/tag/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tag.module';
+export * from './tag.component';

package/lib/components/tag/tag.component.d.ts

@@ -0,0 +1,10 @@
+import { Color } from '../../styles';
+import * as i0 from "@angular/core";
+export declare class TagComponent {
+    hostClass: boolean;
+    color?: Color;
+    icon: import("@angular/core").InputSignal<string | undefined>;
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "v-tag", never, { "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}

package/lib/components/tag/tag.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tag.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/chips";
+import * as i4 from "@angular/material/icon";
+export declare class TagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TagModule, [typeof i1.TagComponent], [typeof i2.CommonModule, typeof i3.MatChipsModule, typeof i4.MatIconModule], [typeof i1.TagComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TagModule>;
+}

package/lib/components/value/components/menu-value.component.d.ts

@@ -0,0 +1,15 @@
+import { TypedParamsValue } from '../types/base-type';
+import * as i0 from "@angular/core";
+export interface MenuItem {
+    label: string;
+    click?: (event: MouseEvent) => void;
+    disabled?: boolean;
+}
+export type MenuValue = TypedParamsValue<'menu', {
+    items: MenuItem[];
+}>;
+export declare class MenuValueComponent {
+    value: import("@angular/core").InputSignal<MenuValue>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuValueComponent, "v-menu-value", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/value/components/value-list.component.d.ts

@@ -0,0 +1,7 @@
+import { Value } from '../types/value';
+import * as i0 from "@angular/core";
+export declare class ValueListComponent {
+    list: import("@angular/core").InputSignal<Value[] | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValueListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValueListComponent, "v-value-list", never, { "list": { "alias": "list"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/value/index.d.ts

@@ -0,0 +1,3 @@
+export * from './value.component';
+export * from './components/value-list.component';
+export * from './types/value';

package/lib/components/value/types/base-type.d.ts

@@ -0,0 +1,19 @@
+import { TemplateRef } from '@angular/core';
+import { Router } from '@angular/router';
+import { Color } from '../../../styles';
+export type BaseValue<V = unknown> = {
+    value?: V;
+    description?: string | number | boolean;
+    tooltip?: string;
+    color?: Color;
+    click?: (event: MouseEvent) => void;
+    link?: (event: MouseEvent) => string | Parameters<Router['navigate']>;
+    template?: TemplateRef<unknown>;
+    inProgress?: boolean;
+};
+export type TypedValue<T, V = unknown> = BaseValue<V> & {
+    type: T;
+};
+export type TypedParamsValue<T, P extends object, V = unknown> = TypedValue<T, V> & {
+    params: P;
+};

package/lib/components/value/types/value.d.ts

@@ -0,0 +1,9 @@
+import { MenuValue } from '../components/menu-value.component';
+import { CurrencyAmountValue } from '../utils/currency-amount-value-to-string';
+import { DatetimeValue } from '../utils/datetime-value-to-string';
+import { BaseValue } from './base-type';
+type TypedBaseValue = BaseValue & {
+    type?: never;
+};
+export type Value = TypedBaseValue | DatetimeValue | MenuValue | CurrencyAmountValue;
+export {};

package/lib/components/value/utils/currency-amount-value-to-string.d.ts

@@ -0,0 +1,8 @@
+import { formatCurrency } from '../../../utils';
+import { TypedParamsValue } from '../types/base-type';
+export type CurrencyAmountValue = TypedParamsValue<'currency', {
+    code: string;
+    exponent?: number;
+    major?: boolean;
+}, Parameters<typeof formatCurrency>[0]>;
+export declare function currencyAmountValueToString(value: CurrencyAmountValue): string;

package/lib/components/value/utils/datetime-value-to-string.d.ts

@@ -0,0 +1,4 @@
+import { formatDate } from '@angular/common';
+import { TypedValue } from '../types/base-type';
+export type DatetimeValue = TypedValue<'datetime', Parameters<typeof formatDate>[0]>;
+export declare function datetimeValueToString(value: DatetimeValue): string;

package/lib/components/value/utils/unknown-to-string.d.ts

@@ -0,0 +1 @@
+export declare function unknownToString(value: unknown): string;

package/lib/components/value/utils/value-to-string.d.ts

@@ -0,0 +1,2 @@
+import { Value } from '../types/value';
+export declare function valueToString(value?: Value | null): string;

package/lib/components/value/value.component.d.ts

@@ -0,0 +1,27 @@
+import { Injector } from '@angular/core';
+import { Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { Nil } from '../../utils';
+import { Value } from './types/value';
+import * as i0 from "@angular/core";
+export declare class ValueComponent {
+    private injector;
+    private router;
+    value: import("@angular/core").InputSignal<Nil | Value>;
+    lazyValue: import("@angular/core").InputSignal<Nil | Observable<Value>>;
+    lazyVisible: import("@angular/core").ModelSignal<boolean>;
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    inline: boolean;
+    emptySymbol: string;
+    highlight?: string | null;
+    value$: Observable<Nil | Value>;
+    valueText$: Observable<string>;
+    inProgress$: Observable<boolean>;
+    constructor(injector: Injector, router: Router);
+    makeLazyVisible(): void;
+    click(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValueComponent, "v-value", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "lazyValue": { "alias": "lazyValue"; "required": false; "isSignal": true; }; "lazyVisible": { "alias": "lazyVisible"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; }; "emptySymbol": { "alias": "emptySymbol"; "required": false; }; "highlight": { "alias": "highlight"; "required": false; }; }, { "lazyVisible": "lazyVisibleChange"; }, never, never, true, never>;
+    static ngAcceptInputType_inline: unknown;
+    static ngAcceptInputType_emptySymbol: unknown;
+}

package/lib/directives/highlight.directive.d.ts

@@ -0,0 +1,15 @@
+import { DestroyRef, ElementRef, Injector, OnInit, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class HighlightDirective implements OnInit {
+    private el;
+    private renderer;
+    private dr;
+    private injector;
+    vHighlightText: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    vHighlightSearch: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    constructor(el: ElementRef, renderer: Renderer2, dr: DestroyRef, injector: Injector);
+    ngOnInit(): void;
+    private escapeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightDirective, "[vHighlight]", never, { "vHighlightText": { "alias": "vHighlightText"; "required": false; "isSignal": true; }; "vHighlightSearch": { "alias": "vHighlightSearch"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/directives/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tooltip.directive';
+export * from './highlight.directive';

package/lib/directives/tooltip.directive.d.ts

@@ -0,0 +1 @@
+export { MtxTooltip as Tooltip } from '@ng-matero/extensions/tooltip';

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './directives';
+export * from './services';
+export * from './pipes';
+export * from './utils';
+export * from './styles';

package/lib/pipes/amount-currency.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AmountCurrencyPipe implements PipeTransform {
+    private _locale;
+    private _defaultCurrencyCode;
+    constructor(_locale: string, _defaultCurrencyCode?: string);
+    transform(amount: unknown, currencyCode?: string, format?: 'short' | 'long', exponent?: number, isMajor?: boolean): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AmountCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AmountCurrencyPipe, "amountCurrency", true>;
+}

package/lib/pipes/enum-key-values.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class EnumKeyValuesPipe implements PipeTransform {
+    transform<E extends Record<PropertyKey, unknown>>(value: E): {
+        key: keyof E;
+        value: import("utility-types").ValuesType<E>;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumKeyValuesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumKeyValuesPipe, "enumKeyValues", true>;
+}

package/lib/pipes/enum-key.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { ValuesType } from 'utility-types';
+import * as i0 from "@angular/core";
+export declare class EnumKeyPipe implements PipeTransform {
+    transform<E extends Record<PropertyKey, unknown>>(value: ValuesType<E>, enumObj: E): "" | keyof E;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumKeyPipe, "enumKey", true>;
+}

package/lib/pipes/enum-keys.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class EnumKeysPipe implements PipeTransform {
+    transform<E extends Record<PropertyKey, unknown>>(value: E): (keyof E)[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumKeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumKeysPipe, "enumKeys", true>;
+}

package/lib/pipes/humanized-duration.pipe.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '@angular/core';
+import { AsyncTransform, AsyncTransformParameters } from '../utils';
+import * as i0 from "@angular/core";
+export type HumanizedDurationValue = ConstructorParameters<DateConstructor>[0];
+export interface HumanizedDurationConfig {
+    hasAgoEnding?: boolean;
+}
+export declare class HumanizedDurationPipe extends AsyncTransform<HumanizedDurationValue, [HumanizedDurationConfig]> implements PipeTransform {
+    protected result$: import("rxjs").Observable<string>;
+    transform(...params: AsyncTransformParameters<HumanizedDurationValue, [HumanizedDurationConfig]>): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HumanizedDurationPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HumanizedDurationPipe, "humanizedDuration", true>;
+}

package/lib/pipes/index.d.ts

@@ -0,0 +1,8 @@
+export * from './pipes.module';
+export * from './inline-json.pipe';
+export * from './enum-key.pipe';
+export * from './enum-keys.pipe';
+export * from './enum-key-values.pipe';
+export * from './amount-currency.pipe';
+export * from './select.pipe';
+export * from './humanized-duration.pipe';

package/lib/pipes/inline-json.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class InlineJsonPipe implements PipeTransform {
+    transform(value: unknown, maxReadableLever?: number | false): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineJsonPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InlineJsonPipe, "inlineJson", false>;
+}

package/lib/pipes/pipes.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./inline-json.pipe";
+import * as i2 from "@angular/common";
+import * as i3 from "./enum-key.pipe";
+import * as i4 from "./enum-keys.pipe";
+import * as i5 from "./enum-key-values.pipe";
+import * as i6 from "./amount-currency.pipe";
+import * as i7 from "./select.pipe";
+import * as i8 from "./humanized-duration.pipe";
+export declare class PipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, [typeof i1.InlineJsonPipe], [typeof i2.CommonModule, typeof i3.EnumKeyPipe, typeof i4.EnumKeysPipe, typeof i5.EnumKeyValuesPipe, typeof i6.AmountCurrencyPipe, typeof i7.VSelectPipe, typeof i8.HumanizedDurationPipe], [typeof i1.InlineJsonPipe, typeof i3.EnumKeyPipe, typeof i4.EnumKeysPipe, typeof i5.EnumKeyValuesPipe, typeof i6.AmountCurrencyPipe, typeof i7.VSelectPipe, typeof i8.HumanizedDurationPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
+}

package/lib/pipes/select.pipe.d.ts

@@ -0,0 +1,12 @@
+import { ChangeDetectorRef, OnDestroy, PipeTransform } from '@angular/core';
+import { SelectFn } from '../utils';
+import * as i0 from "@angular/core";
+export declare class VSelectPipe<TObject extends object, TResult, TParams extends Array<unknown> = []> implements PipeTransform, OnDestroy {
+    private ref;
+    private asyncPipe?;
+    constructor(ref: ChangeDetectorRef);
+    transform(obj: TObject, selectFn: SelectFn<TObject, TResult, TParams>, defaultValue?: TResult, rest?: TParams[]): TResult | null;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VSelectPipe<any, any, any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<VSelectPipe<any, any, any>, "vSelect", true>;
+}

package/lib/services/config/config.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class ConfigServiceSuperclass<T> {
+    private http;
+    config: T;
+    constructor(http: HttpClient);
+    init({ configUrl }: {
+        configUrl: string;
+    }): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigServiceSuperclass<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigServiceSuperclass<any>>;
+}

package/lib/services/config/index.d.ts

@@ -0,0 +1 @@
+export * from './config.service';

package/lib/services/fetch-superclass/fetch-superclass.d.ts

@@ -0,0 +1,39 @@
+import { Observable } from 'rxjs';
+export interface Action<TParams> {
+    type: 'load' | 'reload' | 'more' | 'init';
+    params?: TParams;
+    size?: number;
+}
+export interface FetchResult<TResultItem, TContinuationToken = string> {
+    result: TResultItem[];
+    continuationToken?: TContinuationToken;
+}
+export interface FetchOptions<TContinuationToken = string> {
+    size: number;
+    continuationToken?: TContinuationToken;
+}
+export interface LoadOptions {
+    size?: number;
+}
+export interface Accumulator<TResultItem, TParams, TContinuationToken> {
+    result: TResultItem[];
+    size: number;
+    params?: TParams;
+    continuationToken?: TContinuationToken;
+}
+export declare abstract class FetchSuperclass<TResultItem, TParams = void, TContinuationToken = string> {
+    result$: Observable<TResultItem[]>;
+    hasMore$: Observable<boolean>;
+    isLoading$: Observable<boolean>;
+    private fetch$;
+    private progress$;
+    private state$;
+    private skipPrevious$;
+    load(params: TParams, options?: LoadOptions): void;
+    reload(options?: LoadOptions): void;
+    more(): void;
+    protected abstract fetch(params: TParams, options: FetchOptions<TContinuationToken>): Observable<FetchResult<TResultItem, TContinuationToken>>;
+}
+export declare abstract class SingleFetchSuperclass<TResultItem, TParams = void> extends FetchSuperclass<TResultItem, TParams, never> {
+    more: () => never;
+}

package/lib/services/fetch-superclass/index.d.ts

@@ -0,0 +1 @@
+export * from './fetch-superclass';

package/lib/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './log';
+export * from './fetch-superclass';
+export * from './query-params';
+export * from './url.service';

package/lib/services/log/index.d.ts

@@ -0,0 +1,2 @@
+export * from './log.module';
+export * from './notify-log.service';

package/lib/services/log/log-error.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_ERROR_NAME = "Unknown error";
+export declare class LogError {
+    source: Record<PropertyKey, unknown>;
+    get name(): string;
+    get message(): string;
+    get cause(): unknown;
+    get details(): {
+        [k: string]: unknown;
+    };
+    constructor(error: unknown);
+    getLogMessage(message?: string): string;
+}

package/lib/services/log/log.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+export declare class LogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LogModule, never, [typeof i1.MatSnackBarModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LogModule>;
+}

package/lib/services/log/notify-log.service.d.ts

@@ -0,0 +1,17 @@
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { PossiblyAsync } from '../../utils';
+import { Operation } from './types/operation';
+import * as i0 from "@angular/core";
+export declare class NotifyLogService {
+    private snackBar;
+    constructor(snackBar: MatSnackBar);
+    success: (message?: PossiblyAsync<string>) => void;
+    error: (errors: unknown | unknown[], message?: PossiblyAsync<string>) => void;
+    createErrorOperation(operation: Operation, objectName: string): (err: unknown) => void;
+    successOperation(operation: Operation, objectName: string): void;
+    errorOperation(errors: unknown | unknown[], operation: Operation, objectName: string): void;
+    private notify;
+    private subscribeWithTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyLogService>;
+}

package/lib/services/log/types/operation.d.ts

@@ -0,0 +1 @@
+export type Operation = 'create' | 'receive' | 'update' | 'delete';

package/lib/services/query-params/index.d.ts

@@ -0,0 +1,4 @@
+export * from './query-params.service';
+export * from './query-params.module';
+export * from './utils';
+export * from './types/serializer';

package/lib/services/query-params/query-params.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class QueryParamsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryParamsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<QueryParamsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<QueryParamsModule>;
+}

package/lib/services/query-params/query-params.service.d.ts

@@ -0,0 +1,37 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { Serializer } from './types/serializer';
+import * as i0 from "@angular/core";
+interface SerializeOptions {
+    filter?: (param: unknown, key: string) => boolean;
+}
+interface BaseQueryParams<T extends object> {
+    params$: Observable<Partial<T>>;
+    params: Partial<T>;
+    set: (params: T, options?: SerializeOptions) => Promise<boolean>;
+    patch: (params: Partial<T>, options?: SerializeOptions) => Promise<boolean>;
+}
+export interface QueryParamsNamespace<T extends object> extends BaseQueryParams<T> {
+    destroy: () => void;
+}
+export declare class QueryParamsService<P extends object = NonNullable<unknown>> implements BaseQueryParams<P> {
+    private router;
+    private route;
+    private readonly serializers?;
+    params$: Observable<P>;
+    get params(): P;
+    private sourceParams$;
+    constructor(router: Router, route: ActivatedRoute, serializers?: Serializer[] | undefined);
+    set(params: P, options?: SerializeOptions): Promise<boolean>;
+    patch(params: Partial<P>, options?: SerializeOptions): Promise<boolean>;
+    createNamespace<TNamespaceParams extends object>(ns: string): QueryParamsNamespace<TNamespaceParams>;
+    private setParams;
+    private getSourceParams;
+    private serialize;
+    private deserialize;
+    private serializeNamespace;
+    private deserializeNamespace;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryParamsService<any>, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryParamsService<any>>;
+}
+export {};

package/lib/services/query-params/types/serializer.d.ts

@@ -0,0 +1,6 @@
+export type Serializer<T = unknown> = {
+    id: string;
+    serialize: (v: T) => string;
+    deserialize: (v: string) => T;
+    recognize: (v: T) => boolean;
+};

package/lib/services/query-params/utils/date-query-params-serializers.d.ts

@@ -0,0 +1,2 @@
+import { Serializer } from '../types/serializer';
+export declare const DATE_QUERY_PARAMS_SERIALIZERS: Serializer[];

package/lib/services/query-params/utils/deserialize-query-param.d.ts

@@ -0,0 +1,2 @@
+import { Serializer } from '../types/serializer';
+export declare function deserializeQueryParam<P>(value: string, serializers?: Serializer[]): P;

package/lib/services/query-params/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './date-query-params-serializers';
+export * from './query-params-serializers';

package/lib/services/query-params/utils/query-params-serializers.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { Serializer } from '../types/serializer';
+export declare const QUERY_PARAMS_SERIALIZERS: InjectionToken<Serializer[]>;

package/lib/services/query-params/utils/serialize-query-param.d.ts

@@ -0,0 +1,2 @@
+import { Serializer } from '../types/serializer';
+export declare function serializeQueryParam(value: unknown, serializers?: Serializer[]): string;

package/lib/services/url.service.d.ts

@@ -0,0 +1,12 @@
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class UrlService {
+    private router;
+    url$: import("rxjs").Observable<string>;
+    path$: import("rxjs").Observable<string[]>;
+    get url(): string;
+    get path(): string[];
+    constructor(router: Router);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UrlService>;
+}

package/lib/styles/index.d.ts

@@ -0,0 +1 @@
+export * from './types/color';

package/lib/styles/types/color.d.ts

@@ -0,0 +1,4 @@
+import { ThemePalette as MatThemePalette } from '@angular/material/core';
+export type ThemePalette = MatThemePalette;
+export type StatusPalette = 'success' | 'pending' | 'neutral';
+export type Color = ThemePalette | StatusPalette;

package/lib/types/progressable.d.ts

@@ -0,0 +1,3 @@
+export interface Progressable {
+    progress?: boolean | number | null | string;
+}

package/lib/utils/async/async-transform.d.ts

@@ -0,0 +1,20 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PossiblyAsync } from './is-async';
+import * as i0 from "@angular/core";
+export type AsyncTransformParameters<TValue = unknown, TParams extends unknown[] = []> = [
+    PossiblyAsync<TValue>,
+    ...TParams
+];
+export declare abstract class AsyncTransform<TValue = unknown, TParams extends unknown[] = [], TResult = string | null> implements OnDestroy {
+    protected abstract result$: Observable<TResult>;
+    protected params$: Observable<[TValue, ...TParams]>;
+    private asyncPipe;
+    private cdr;
+    private args$;
+    constructor();
+    ngOnDestroy(): void;
+    protected asyncTransform(args: AsyncTransformParameters<TValue, TParams>): TResult | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncTransform<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncTransform<any, any, any>>;
+}