import * as rxjs from 'rxjs';
import { Observable, Subject, MonoTypeOperatorFunction, BehaviorSubject, ReplaySubject } from 'rxjs';
import { DataSource } from '@angular/cdk/table';
import { CollectionViewer } from '@angular/cdk/collections';
import * as i0 from '@angular/core';
import { ViewContainerRef, ElementRef, TemplateRef, PipeTransform, InjectionToken, OnChanges, OnDestroy, Renderer2, SimpleChanges } from '@angular/core';
import { HttpClient, HttpHeaders, HttpParams, HttpRequest, HttpErrorResponse } from '@angular/common/http';
import { CdkScrollable } from '@angular/cdk/overlay';
import * as i1 from '@angular/common';

declare function memoize(props: any, name: any, descriptor: any): {
    configurable: boolean;
    value: () => any;
};

declare function memoizeStream(props: any, name: any, descriptor: any): {
    configurable: boolean;
    value: () => any;
};

interface DispatchEvent {
    data: any;
    key: any;
}
type Storage<Key, Value> = Map<Key, Value>;
interface DataStore {
    push(key: any, value: any): any;
    pull(key: any): any;
    observe(key: any): Observable<any>;
    clear(key: any): any;
    clearAll(): any;
}

type Timestamp = number;
declare const PerishableTTL: number;
interface Perishable {
    expiryDate?: Timestamp;
    [prop: string]: any;
}
interface CacheStore<T extends Perishable> {
    [identifier: string]: any;
}
interface RepositoryLoadQuery {
    ids?: any[];
    [prop: string]: any;
}

declare enum StoreStrategy {
    Merge = 0,
    Replace = 1
}
declare class RepositoryCacheStore<T extends Perishable> {
    readonly namespace: string;
    protected store: DataStore;
    constructor(namespace: string, store: DataStore);
    protected get storeKey(): string;
    setExtractIdentifierStrategy(fn: (T: any) => any): void;
    observeCache(): Observable<CacheStore<T>>;
    observe(ids?: any | any[]): Observable<T[]>;
    pull(ids?: any | any[]): T[];
    push(data: T[] | T, strategy?: StoreStrategy): T[];
    removeItems(ids: any | any[]): T[];
    dataToIdentifier(data: T): any;
    set(id: any, data: T): void;
    clear(): void;
    getCache(): CacheStore<T>;
    getMissingIdentifiers(ids: any | any[], outdatedAsMissing?: boolean): any[];
    getOutdatedCachedIdentifiers(): string[];
    isMissingIdentifier(id: any): boolean;
    isOutdated(datum: T, time?: Timestamp): boolean;
    protected extractIdentifierFn: (T: any) => any;
    protected cacheToList(store: CacheStore<T>, ids?: any[]): T[];
}

declare class RepositoryInvalidIdCacheStore {
    readonly namespace: any;
    protected store: DataStore;
    constructor(namespace: any, store: DataStore);
    protected get storeKey(): string;
    add(ids: any[] | any): any[];
    push(ids: any[]): any[];
    pull(): any[];
    clear(): void;
    filterInvalidIds(ids: any[]): any[];
}

declare enum UpdateCacheStrategy {
    Replace = 0,
    Merge = 1
}
interface RepositoryOptions {
    /**
     * item time to live, the repository triggers queryData if the data's outdated
     * 0 means infinite ttl
     */
    itemTTL?: number;
}
declare abstract class Repository<T extends Perishable, SearchQuery = any> {
    readonly namespace: string;
    protected cache: RepositoryCacheStore<T>;
    protected invalidIdCache: RepositoryInvalidIdCacheStore;
    protected options: RepositoryOptions;
    constructor(namespace: string, store: DataStore, options?: RepositoryOptions);
    get cacheStore(): RepositoryCacheStore<T>;
    abstract queryData(query?: SearchQuery & RepositoryLoadQuery): Observable<T[]>;
    isOutdated(id: any, missingAsOutdated?: boolean): boolean;
    pull(ids?: any | any[]): T[];
    observe(ids?: any | any[]): Observable<T[]>;
    dataToIdentifier(datum: T): any;
    dataToIdentifiers(data: T[]): any[];
    get(ids: any | any[], refreshOutdated?: boolean): Observable<T[]>;
    getOne(id: any, refreshOutdated?: boolean): Observable<T>;
    refresh(ids?: any | any[]): Observable<T[]>;
    load(query?: SearchQuery & RepositoryLoadQuery, observeResults?: boolean): Observable<T[]>;
    reload(query?: SearchQuery & RepositoryLoadQuery, observeResults?: boolean): Observable<T[]>;
    clear(): void;
    markAsOutdated(ids: any | any[]): boolean;
    markAllAsOutdated(): boolean;
    markMatchingItemsAsOutdated(fn: (item: T) => boolean): boolean;
    updateCachedItem(id: any, data: any, refreshTTL?: boolean, strategy?: UpdateCacheStrategy): T;
    removeCachedItems(ids: any | any[]): T[];
    cacheItems(data: T | T[], strategy?: StoreStrategy): T[];
    protected _load(query?: SearchQuery & RepositoryLoadQuery, strategy?: StoreStrategy): Observable<T[]>;
    protected setItemTTL(data: any, time?: Timestamp): T;
    protected loadByIds(ids: any[]): Observable<T[]>;
    protected mergeItem(item: T, data: any): T;
}

type FetchQueryFilter<T = any> = T;
type FetchQueryFilters<T = any> = FetchQueryFilter<T>[];
interface FetchQuerySort {
    operand: string;
    direction?: 'asc' | 'desc';
}
interface FetchQueryPagination {
    page: number;
    limit: number;
}
interface FetchQuery {
    filters?: FetchQueryFilters;
    sort?: FetchQuerySort;
    pagination: FetchQueryPagination;
}
interface SourceStore<T> {
    storeChange: Observable<void>;
    length: number;
    total: number;
    isChunkLoaded(start: number, end: number): boolean;
    observe(start: number, end?: number): Observable<T[]>;
    fetch(query: FetchQuery): Observable<{
        data: T[];
        total: number;
    }>;
    clear(): void;
}

declare class RxCleaner<T = string> {
    protected stream: Subject<T>;
    unsubscribe(namespace: T): void;
    unsubscribeAll(): void;
    takeUntil(namespace?: T): MonoTypeOperatorFunction<any>;
    complete(): void;
}

interface FetchedDataSourceConfig {
    pagination?: {
        page?: number;
        limit?: number;
    };
    sort?: FetchQuerySort;
    filters?: FetchQueryFilters;
    fetchAtInit?: boolean;
}
type ReplaceFilterFn = (filter: FetchQueryFilter, index: number) => FetchQueryFilter;
declare class FetchedDataSource<T> extends DataSource<T> {
    protected store: SourceStore<T>;
    protected readonly _totalChange: BehaviorSubject<number>;
    protected readonly _fetching: BehaviorSubject<boolean>;
    protected readonly renderData: BehaviorSubject<T[]>;
    protected readonly paginationChange: ReplaySubject<FetchQueryPagination>;
    protected readonly filtersChange: Subject<FetchQueryFilters>;
    protected readonly _reload: Subject<boolean>;
    protected readonly sortChange: Subject<FetchQuerySort>;
    protected readonly rc: RxCleaner;
    protected listenchanges: boolean;
    protected offChanged: boolean;
    constructor(store: SourceStore<T>, { pagination, sort, filters, fetchAtInit }?: FetchedDataSourceConfig);
    protected _filters: FetchQueryFilters;
    get filters(): FetchQueryFilters;
    set filters(filters: FetchQueryFilters);
    protected _sort: FetchQuerySort;
    get sort(): FetchQuerySort;
    set sort(sort: FetchQuerySort);
    protected _pagination: FetchQueryPagination;
    get pagination(): FetchQueryPagination;
    set pagination(pagination: FetchQueryPagination);
    get totalChange(): Observable<number>;
    get isFetching(): boolean;
    get fetching(): Observable<boolean>;
    get total(): number;
    get totalLoaded(): number;
    reload(page?: number): void;
    updatePagination(pagination: {
        page?: number;
        limit?: number;
    }): boolean;
    updateSort(sort: {
        operand?: string;
        direction?: 'asc' | 'desc';
    }): boolean;
    addFilters(filters: FetchQueryFilters | FetchQueryFilter): void;
    connect(collectionViewer: CollectionViewer): Observable<T[] | ReadonlyArray<T>>;
    disconnect(collectionViewer: CollectionViewer): void;
    destroy(): void;
    protected handleOfflineChange(): void;
    protected updateDataChangeSubscription(): void;
    protected updateRenderChangeSubscription(): void;
    protected fetchData(): Observable<{
        total: number;
        data: T[];
    }>;
}

declare class PaginatedFetchedDataSource<T> extends FetchedDataSource<T> {
    protected updateRenderChangeSubscription(): void;
}

interface OutletDirective {
    viewContainer: ViewContainerRef;
    elementRef: ElementRef;
}
interface TemplateDefDirective<T = any> {
    template: TemplateRef<T>;
}

declare class UnicodeEncoder {
    static toBase64(value: string): string;
    static fromBase64(base64: string): string;
    static b64ToUint6(nChr: number): number;
    static base64DecToArr(sBase64: string, nBlocksSize?: number): Uint8Array;
    static uint6ToB64(nUint6: number): number;
    static base64EncArr(aBytes: Uint8Array): string;
    static UTF8ArrToStr(aBytes: Uint8Array): string;
    static strToUTF8Arr(sDOMStr: string): Uint8Array;
}

declare class Encoder {
    static urlBase64Decode(str: string): string;
    static b64decode(str: string): string;
    static b64DecodeUnicode(str: any): string;
}

declare class JwtHelperErrors {
    static readonly ErrorDecodeToken = "Cannot decode the token.";
    static readonly ErrorInvalidJWT = "The inspected token doesn't appear to be a JWT.";
}
declare class JwtHelper {
    static decodeToken(token: any): any;
}

declare class NumberFormatter {
    static microToMoney(value: number): number;
    static moneyToMicro(value: number): number;
    static truncate(value: number, precision?: number): number;
    static shorten(number: number, precision?: number): string;
}
declare function min(value: number, boundaryValue: number): number;
declare function max(value: number, boundaryValue: number): number;
declare function minmax(value: number, minBoundary: number, maxBoundary: number): number;

declare class UrlParser {
    static a: HTMLAnchorElement;
    static getAnchor(href?: string): HTMLAnchorElement;
    static hostname(url?: string): string;
    static search(url?: string): string;
    static decodedHostname(url?: string): string;
    static extractSearchParams(url?: string): {};
    static implodeSearchParams(params?: any): string;
}

declare class Check {
    static isDefined(val: any, allowNull?: boolean): boolean;
    static everyDefined(val: any[], allowNull?: boolean): boolean;
    static someDefined(val: any[], allowNull?: boolean): boolean;
    static propertyExists(data: any, property: PropertyKey): any;
    static isEqual(itemA: any, itemB: any, depth?: number): any;
    static isEmpty(val: string | any[] | object): boolean;
}

declare class ArrayUtils {
    static asArray(data?: any | any[]): any[];
    static isArrayOfLength(subject: any, expectedLength: number): boolean;
    static intersect<T>(...arrs: T[][]): T[];
    static except<T>(...arrs: T[][]): T[];
    static uniq<T>(array: T[]): T[];
}

type StateMap<State> = Map<State, boolean>;
type StateMapSource<State> = StateMap<State> | Iterable<[State, boolean]> | [State, boolean][];
interface StateChangeEvent<State = any> {
    state: State;
    value: boolean;
}
declare class StateManager<State = any> {
    protected states: StateMap<State>;
    protected baseStates: StateMap<State>;
    constructor(states?: StateMapSource<State>);
    protected _stateChange: Subject<StateChangeEvent>;
    get stateChange(): Observable<StateChangeEvent>;
    is(state: State): boolean;
    not(state: State): boolean;
    set(state: State, value: boolean): void;
    active(state: State): void;
    deactive(state: State): void;
    toggle(state: State): boolean;
    takeWhen(state: State): MonoTypeOperatorFunction<any>;
    skipWhen(state: State): MonoTypeOperatorFunction<any>;
    reset(states?: StateMapSource<State>): void;
    destroy(): void;
}

declare function coerceObject<T>(val: T): T extends Record<string, any> ? T : Record<string, undefined>;
declare function coerceNullable<T>(value?: T, defaultValue?: T): T | null;
declare function coerceObservable<T>(data: Observable<T> | T): Observable<T>;
declare function coerceMap<K, V>(data: Map<K, V> | Iterable<[K, V]> | [K, V][]): Map<K, V>;
declare function coerceArray<T>(val: T | T[] | null | undefined, nullAsEmpty?: boolean): T[];
declare function coerceValue<T>(value: T | any, allowedValues: T[], defaultValue?: T): T;
type coercionFn<T> = (value: any) => T;
declare function coerceEnumerableProperty<T>(value: any, values: T[], defaultValue?: T): T;
declare function createCoerceEnumerablePropertyFn<T>(values: T[], defaultValue?: T): coercionFn<T>;

/**
 * Test purpose only
 */
declare class DataStoreStub implements DataStore {
    readonly changeStream: ReplaySubject<void>;
    storage: Storage<any, any>;
    clear(key: any): void;
    clearAll(): void;
    observe(key: any): Observable<any>;
    pull(key: any): any;
    push(key: any, value: any): any;
}

declare class DataStoreService implements DataStore {
    protected storage: Storage<any, any>;
    protected eventStream: Subject<DispatchEvent>;
    clear(key: any): void;
    clearAll(): void;
    pull(key: any): any;
    push(key: any, data?: any): any;
    observe(toObserve: any): rxjs.Observable<any>;
    protected dispatch(event: DispatchEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataStoreService>;
}

declare abstract class MockFactory<T, Opts = any> {
    abstract generate(opt?: Opts): T;
    seed(override?: Partial<T>, opt?: Opts): T;
    sperm(iteration: number, override?: Partial<T>, opt?: Opts): T[];
}

interface DummyObject {
    id: number;
    [prop: string]: any;
}
declare class DummyMockFactory extends MockFactory<DummyObject> {
    static id: number;
    generate(): DummyObject;
}

type HydraItem<T = any> = T & {
    '@id': string;
    '@type': string;
    '@context'?: string;
};
interface HydraCollection<T = any> {
    '@context': string;
    '@id': string;
    '@type': string;
    'hydra:member': HydraItem<T>[];
    'hydra:totalItems': number;
    'hydra:view': {
        '@id': string;
        '@type': string;
        'hydra:first'?: string;
        'hydra:last'?: string;
        'hydra:next'?: string;
    };
}

declare class HydraFactory {
    static generateCollection<T extends {
        id: any;
    }>(items: T[], total?: number, type?: string): HydraCollection<T>;
    static generateItem<T extends {
        id: any;
    }>(item: T, type?: string): HydraItem<T>;
}

interface ApiHttpResponse<T> {
    data: T[];
    count?: number;
    total?: number;
    [prop: string]: any;
}
interface ApiHydraHttpResponse<T> extends ApiHttpResponse<T> {
    metadata: {
        '@context': string;
        '@id': string;
        '@type': string;
        [prop: string]: any;
    };
}

type HydraId = string;
declare class Hydra {
    static id(item: HydraId | object): HydraId;
    static normalizeResponse(response: HydraItem | HydraCollection): ApiHydraHttpResponse<any>;
}

declare class ApiResponseHelper {
    static getDataFromResponse(response: ApiHttpResponse<any>, returnFirstResult?: boolean): any;
    static getCountFromResponse(response: ApiHttpResponse<any>): number;
    static getTotalFromResponse(response: ApiHttpResponse<any>): number;
}

interface HttpOptions {
    headers?: HttpHeaders;
    observe?: 'body';
    params?: HttpParams;
    [prop: string]: any;
}
declare abstract class HttpEndpoint {
    protected http: HttpClient;
    constructor(http: HttpClient);
    abstract getEndpointHost(): any;
    get(url: string, options?: HttpOptions): Observable<any>;
    post(url: string, body: any, options?: HttpOptions): Observable<any>;
    put(url: string, body: any, options?: HttpOptions): Observable<any>;
    delete(url: string, options?: HttpOptions): Observable<any>;
    patch(url: string, body: any, options?: HttpOptions): Observable<any>;
    head(url: string, options?: HttpOptions): Observable<any>;
    request(request: HttpRequest<any>): Observable<any>;
    prepareUrl(url: string): string;
    protected parseErrorResponse(response?: HttpErrorResponse): Observable<never>;
}

declare function arrayFirst<T>(): (source: Observable<T[]>) => Observable<T>;
declare function arrayLast<T>(): (source: Observable<T[]>) => Observable<T>;

declare function mapHttpData<T, P>(mapFn: (item: T) => P): (source: Observable<ApiHttpResponse<T>>) => Observable<ApiHttpResponse<P>>;
declare function getHttpData<T>(returnFirstResult?: boolean): (source: Observable<ApiHttpResponse<T>>) => Observable<any>;
declare function mapHydraResponse<T>(): (source: Observable<HydraItem | HydraCollection>) => Observable<ApiHydraHttpResponse<T>>;

declare class UCFirstPipe implements PipeTransform {
    transform(text: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UCFirstPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UCFirstPipe, "ucfirst", true>;
}

declare class PrependPipe implements PipeTransform {
    transform(token: string, prefix?: string, glue?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrependPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PrependPipe, "prepend", true>;
}

declare class AppendPipe implements PipeTransform {
    transform(token: string, suffix?: string, glue?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppendPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AppendPipe, "append", true>;
}

declare class CoalescePipe implements PipeTransform {
    transform(value: any, replaceValue: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoalescePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CoalescePipe, "coalesce", true>;
}

declare class PadStartPipe implements PipeTransform {
    transform(value: any, length: number, filler: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PadStartPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PadStartPipe, "padStart", true>;
}

declare class PadEndPipe implements PipeTransform {
    transform(value: any, length: number, filler: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PadEndPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PadEndPipe, "padEnd", true>;
}

declare class ShortNumberPipe implements PipeTransform {
    transform(value: number, precision?: number): string | any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ShortNumberPipe, "shortNumber", true>;
}

declare const FLEX_SCROLL_CONTAINER: InjectionToken<unknown>;
declare class FlexScrollContainerComponent {
    cdkScrollable: CdkScrollable;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlexScrollContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlexScrollContainerComponent, "flex-scroll-container,[flex-scroll-container]", never, {}, {}, never, ["*"], true, never>;
}

declare class StopPropagationDirective implements OnChanges, OnDestroy {
    protected ref: ElementRef<any>;
    protected render: Renderer2;
    eventName: string;
    protected _listener: () => void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    lockPropagation(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StopPropagationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StopPropagationDirective, "[stopPropagation]", never, { "eventName": { "alias": "stopPropagation"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CommonToolsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonToolsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonToolsModule, never, [typeof UCFirstPipe, typeof PrependPipe, typeof AppendPipe, typeof CoalescePipe, typeof PadStartPipe, typeof PadEndPipe, typeof ShortNumberPipe, typeof FlexScrollContainerComponent, typeof StopPropagationDirective], [typeof UCFirstPipe, typeof PrependPipe, typeof AppendPipe, typeof CoalescePipe, typeof PadStartPipe, typeof PadEndPipe, typeof ShortNumberPipe, typeof FlexScrollContainerComponent, typeof StopPropagationDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CommonToolsModule>;
}

declare class CommonDevToolsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonDevToolsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonDevToolsModule, never, [typeof i1.CommonModule, typeof CommonToolsModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CommonDevToolsModule>;
}

export { ApiResponseHelper, AppendPipe, ArrayUtils, Check, CoalescePipe, CommonDevToolsModule, CommonToolsModule, DataStoreService, DataStoreStub, DummyMockFactory, Encoder, FLEX_SCROLL_CONTAINER, FetchedDataSource, FlexScrollContainerComponent, HttpEndpoint, Hydra, HydraFactory, JwtHelper, JwtHelperErrors, MockFactory, NumberFormatter, PadEndPipe, PadStartPipe, PaginatedFetchedDataSource, PerishableTTL, PrependPipe, Repository, RepositoryCacheStore, RepositoryInvalidIdCacheStore, RxCleaner, ShortNumberPipe, StateManager, StopPropagationDirective, StoreStrategy, UCFirstPipe, UnicodeEncoder, UpdateCacheStrategy, UrlParser, arrayFirst, arrayLast, coerceArray, coerceEnumerableProperty, coerceMap, coerceNullable, coerceObject, coerceObservable, coerceValue, createCoerceEnumerablePropertyFn, getHttpData, mapHttpData, mapHydraResponse, max, memoize, memoizeStream, min, minmax };
export type { ApiHttpResponse, ApiHydraHttpResponse, CacheStore, DataStore, DispatchEvent, DummyObject, FetchQuery, FetchQueryFilter, FetchQueryFilters, FetchQueryPagination, FetchQuerySort, FetchedDataSourceConfig, HttpOptions, HydraCollection, HydraId, HydraItem, OutletDirective, Perishable, ReplaceFilterFn, RepositoryLoadQuery, RepositoryOptions, SourceStore, StateChangeEvent, StateMap, StateMapSource, Storage, TemplateDefDirective, Timestamp, coercionFn };