import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject } from 'rxjs';
import { FormControl } from '@angular/forms';
import { HttpClient } from '@angular/common/http';
import * as i0 from '@angular/core';
import { TemplateRef, OnInit, OnDestroy, ChangeDetectorRef, InjectionToken, EnvironmentProviders } from '@angular/core';

declare abstract class CollectionProvider<T> {
    protected cachedRequestParams: Record<string, CollectionApiParams> | null;
    abstract transform(request: CollectionRequest, context: CollectionContext<T>): Observable<CollectionData<T>>;
    protected validateParams(request: Record<string, CollectionApiParams>, _context: CollectionContext<T>): Record<string, CollectionApiParams>;
    protected formatArrayToCollectionData(items: T[]): CollectionData<T>;
    protected deepCompare(value1: unknown, value2: unknown): boolean;
}

declare const enum CollectionState {
    Initial = "initial",
    Error = "error",
    Empty = "empty",
    Data = "data"
}
declare class Collection<T> {
    private readonly _provider;
    readonly _initialValues: Partial<CollectionRequest>;
    readonly queryControl: FormControl<string | null>;
    readonly queryFieldsControl: FormControl<string[]>;
    readonly pageNumberControl: FormControl<number>;
    readonly pageSizeControl: FormControl<number>;
    readonly sortControl: FormControl<CollectionRequestSort | CollectionRequestSort[]>;
    readonly data$: Observable<{
        response?: CollectionData<T>;
        request?: CollectionRequest;
        error?: Error;
        state: CollectionState;
        loading: boolean;
        initial: boolean;
    }>;
    readonly raw$: BehaviorSubject<CollectionData<T>>;
    readonly loading$: BehaviorSubject<boolean>;
    private _formatter;
    private _refresh$;
    constructor(_provider: CollectionProvider<T>, _initialValues?: Partial<CollectionRequest>);
    refresh(): void;
    setFormatter(callback: (items: T[]) => T[] | Observable<T[]>): this;
    private getData;
    private formatResponse;
    private getState;
    private cacheCollectionData;
    private get request();
    private getQueryObservable;
}

interface CollectionRequest {
    pageNumber: number;
    pageSize: number;
    query: string | null;
    queryFields: string[];
    sort: CollectionRequestSort | CollectionRequestSort[];
}
interface CollectionRequestSort<T = string> {
    name: T;
    direction: 'asc' | 'desc';
}
interface CollectionData<T> {
    pageNumber: number;
    pageSize: number;
    totalPages: number;
    totalEntries: number;
    data: T[];
    raw?: any;
}
interface CollectionApiResponse<T> {
    page_number: number;
    page_size: number;
    total_pages: number;
    total_entries: number;
    data: T[];
    [key: string]: unknown;
}
type CollectionApiParams = string | number | boolean | ReadonlyArray<string | number | boolean>;
interface CollectionContext<T> {
    collection: Collection<T>;
}

type ArrayCollectionStringKeys<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];
interface ArrayCollectionOptions<T> {
    sortables?: Partial<Record<ArrayCollectionStringKeys<T>, 'string' | 'number'>>;
}

declare class ApiCollectionProvider<T> extends CollectionProvider<T> {
    protected readonly endpoint: string | Observable<string>;
    protected readonly httpClient: HttpClient;
    protected extraParams: Record<string, Observable<CollectionApiParams>>;
    protected extraObjectParams: Observable<Record<string, CollectionApiParams>>[];
    constructor(endpoint: string | Observable<string>, httpClient: HttpClient);
    append(name: string, value: CollectionApiParams | Observable<CollectionApiParams>): this;
    appendObject(value: Record<string, CollectionApiParams> | Observable<Record<string, CollectionApiParams>>): void;
    transform(request: CollectionRequest, context: CollectionContext<T>): Observable<CollectionData<T>>;
    protected validateParams(request: Record<string, CollectionApiParams>, context: CollectionContext<T>): Record<string, CollectionApiParams>;
    protected getExtraParams(params: Record<string, Observable<CollectionApiParams>>): Observable<{}>;
    protected getExtraObjectParams(params$: Observable<Record<string, CollectionApiParams>>[]): Observable<{}>;
    protected formatToCollectionData(response: CollectionApiResponse<T> | T[]): CollectionData<T>;
    protected getBackendFormat(request: CollectionRequest): {};
}

declare class LocalCollectionProvider<T> extends CollectionProvider<T> {
    private _options?;
    private _items$;
    constructor(items: T[], _options?: ArrayCollectionOptions<T>);
    update(value: T[]): void;
    transform(request: CollectionRequest): rxjs.Observable<{
        totalPages: number;
        totalEntries: number;
        pageSize: number;
        pageNumber: number;
        data: T[];
    }>;
}

declare class BbCollectionsDataContext<T> {
    items: T[];
    loading: boolean;
    constructor(items: T[], loading: boolean);
}
declare class BbCollectionsData<T> {
    template: TemplateRef<BbCollectionsDataContext<T>>;
    constructor(template: TemplateRef<BbCollectionsDataContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsData<T>, ctx: unknown): ctx is BbCollectionsDataContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsData<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsData<any>, "ng-template[bbCollectionsData]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsDataRowContext<T> {
    item: T;
    $implicit: T;
    constructor(item: T);
}
declare class BbCollectionsDataRow<T> {
    template: TemplateRef<BbCollectionsDataRowContext<T>>;
    constructor(template: TemplateRef<BbCollectionsDataRowContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsDataRow<T>, ctx: unknown): ctx is BbCollectionsDataRowContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsDataRow<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsDataRow<any>, "ng-template[bbCollectionsDataRow]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsEmptyContext<T> {
    query: string;
    loading: boolean;
    constructor(query: string, loading: boolean);
}
declare class BbCollectionsEmpty<T> {
    template: TemplateRef<BbCollectionsEmptyContext<T>>;
    constructor(template: TemplateRef<BbCollectionsEmptyContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsEmpty<T>, ctx: unknown): ctx is BbCollectionsEmptyContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsEmpty<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsEmpty<any>, "ng-template[bbCollectionsEmpty]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsErrorContext<T> {
    error: Error;
    loading: boolean;
    constructor(error: Error, loading: boolean);
}
declare class BbCollectionsError<T> {
    template: TemplateRef<BbCollectionsErrorContext<T>>;
    constructor(template: TemplateRef<BbCollectionsErrorContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsError<T>, ctx: unknown): ctx is BbCollectionsErrorContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsError<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsError<any>, "ng-template[bbCollectionsError]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsInitialContext<T> {
}
declare class BbCollectionsInitial<T> {
    template: TemplateRef<BbCollectionsInitialContext<T>>;
    constructor(template: TemplateRef<BbCollectionsInitialContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsInitial<T>, ctx: unknown): ctx is BbCollectionsInitialContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsInitial<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsInitial<any>, "ng-template[bbCollectionsInitial]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsItemContext<T> {
    item: T;
    $implicit: T;
    constructor(item: T);
}
declare class BbCollectionsItem<T> {
    template: TemplateRef<BbCollectionsItemContext<T>>;
    constructor(template: TemplateRef<BbCollectionsItemContext<T>>);
    static ngTemplateContextGuard<T>(dir: BbCollectionsItem<T>, ctx: unknown): ctx is BbCollectionsItemContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsItem<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbCollectionsItem<any>, "ng-template[bbCollectionsItem]", never, {}, {}, never, never, true, never>;
}

declare class BbCollectionsViewer<T = unknown> {
    dataTemplate?: TemplateRef<BbCollectionsDataContext<T>>;
    emptyTemplate?: TemplateRef<BbCollectionsEmptyContext<T>>;
    errorTemplate?: TemplateRef<BbCollectionsErrorContext<T>>;
    initialTemplate?: TemplateRef<BbCollectionsInitialContext<T>>;
    collection: Collection<T> | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsViewer<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsViewer<any>, "[bb-collections-viewer]", never, { "collection": { "alias": "collection"; "required": false; }; }, {}, ["dataTemplate", "emptyTemplate", "errorTemplate", "initialTemplate"], never, true, never>;
}

declare class BbCollectionsPager implements OnInit, OnDestroy {
    private readonly _config?;
    readonly arrowPreviousIconName: string;
    readonly arrowNextIconName: string;
    set maxAmountOfButtons(value: number);
    get maxAmountOfButtons(): number;
    set collection(collection: Collection<unknown> | null);
    get collection(): Collection<unknown> | null;
    data$: Observable<{
        start?: number;
        end?: number;
        totalEntries?: number;
        totalPages?: number;
        pageNumber?: number;
        pages?: {
            page: number;
            active: boolean;
        }[];
    }>;
    private _collection;
    private _subscription;
    private _cache$;
    private _maxAmountOfButtons$;
    ngOnInit(): void;
    ngOnDestroy(): void;
    setPage(pageNumber: number, totalPages: number): void;
    private setData;
    private observeCollectionChanges;
    private calculatePages;
    private filterActivePages;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsPager, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsPager, "bb-collections-pager", never, { "maxAmountOfButtons": { "alias": "maxAmountOfButtons"; "required": false; }; "collection": { "alias": "collection"; "required": true; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_maxAmountOfButtons: unknown;
}

declare class BbCollectionsTable<T = any> {
    readonly collection$: BehaviorSubject<Collection<T>>;
    dataTemplate?: TemplateRef<BbCollectionsDataContext<T>>;
    dataRowTemplate?: TemplateRef<BbCollectionsDataRowContext<T>>;
    queryPlaceholder: string | null;
    emptyContent: string | TemplateRef<any> | null;
    noResultsContent: string | TemplateRef<any> | null;
    errorContent: string | TemplateRef<any> | null;
    trackByProperty: string | null;
    includeVerticalLines: boolean;
    hideActions: boolean;
    hidePager: boolean;
    set collection(collection: Collection<T>);
    get collection(): Collection<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsTable<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsTable<any>, "bb-collections-table", never, { "queryPlaceholder": { "alias": "queryPlaceholder"; "required": false; }; "emptyContent": { "alias": "emptyContent"; "required": false; }; "noResultsContent": { "alias": "noResultsContent"; "required": false; }; "errorContent": { "alias": "errorContent"; "required": false; }; "trackByProperty": { "alias": "trackByProperty"; "required": false; }; "includeVerticalLines": { "alias": "includeVerticalLines"; "required": false; }; "hideActions": { "alias": "hideActions"; "required": false; }; "hidePager": { "alias": "hidePager"; "required": false; }; "collection": { "alias": "collection"; "required": true; }; }, {}, ["dataTemplate", "dataRowTemplate"], ["[data-collections-action]", "[data-collections-row]", "[data-collections-header]", "thead", "tfoot"], true, never>;
    static ngAcceptInputType_includeVerticalLines: unknown;
    static ngAcceptInputType_hideActions: unknown;
    static ngAcceptInputType_hidePager: unknown;
}

declare class BbCollectionsTableSorting implements OnInit, OnDestroy {
    private _name;
    private _changeDetectorRef;
    private _parent?;
    readonly orderedOptions: [null, 'asc', 'desc'];
    direction: 'asc' | 'desc' | null;
    private _subscription;
    constructor(_name: string, _changeDetectorRef: ChangeDetectorRef, _parent?: BbCollectionsTable<unknown>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onClick(): void;
    private getNextOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsTableSorting, [{ attribute: "bb-collections-table-sorting"; }, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsTableSorting, "th[bb-collections-table-sorting]", never, {}, {}, never, ["*"], true, never>;
}

declare class BbCollectionsTableLabel {
    titleLabel: string | TemplateRef<any> | null;
    descriptionLabel: string | TemplateRef<any> | null;
    imageUrl: string | null;
    alt: string | null;
    type: 'image' | 'avatar' | 'content';
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsTableLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsTableLabel, "[bb-collections-table-label]", never, { "titleLabel": { "alias": "titleLabel"; "required": true; }; "descriptionLabel": { "alias": "descriptionLabel"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class BbCollectionsGrid<T> {
    readonly collection$: BehaviorSubject<Collection<T>>;
    itemTemplate?: TemplateRef<BbCollectionsItemContext<T>>;
    queryPlaceholder: string | null;
    emptyContent: string | TemplateRef<any> | null;
    noResultsContent: string | TemplateRef<any> | null;
    errorContent: string | TemplateRef<any> | null;
    trackByProperty: string | null;
    hideActions: boolean;
    hidePager: boolean;
    set collection(collection: Collection<T>);
    get collection(): Collection<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsGrid<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsGrid<any>, "bb-collections-grid", never, { "queryPlaceholder": { "alias": "queryPlaceholder"; "required": false; }; "emptyContent": { "alias": "emptyContent"; "required": false; }; "noResultsContent": { "alias": "noResultsContent"; "required": false; }; "errorContent": { "alias": "errorContent"; "required": false; }; "trackByProperty": { "alias": "trackByProperty"; "required": false; }; "hideActions": { "alias": "hideActions"; "required": false; }; "hidePager": { "alias": "hidePager"; "required": false; }; "collection": { "alias": "collection"; "required": true; }; }, {}, ["itemTemplate"], ["[data-collections-action]", "[data-collections-row]"], true, never>;
    static ngAcceptInputType_hideActions: unknown;
    static ngAcceptInputType_hidePager: unknown;
}

declare class BbCollectionsActions<T> {
    private readonly _config?;
    readonly searchIconName: string;
    readonly closeIconName: string;
    collection: Collection<T> | null;
    queryPlaceholder: string | null;
    standalone: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCollectionsActions<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCollectionsActions<any>, "bb-collections-actions", never, { "collection": { "alias": "collection"; "required": true; }; "queryPlaceholder": { "alias": "queryPlaceholder"; "required": false; }; "standalone": { "alias": "standalone"; "required": false; }; }, {}, never, ["[data-collections-action]", "*"], true, never>;
    static ngAcceptInputType_standalone: unknown;
}

declare class ArrayCollection<T> {
    protected value: T[];
    constructor(value: T[]);
    search(query: string, fields: ArrayCollectionStringKeys<T>[]): this;
    sortBy(sort: CollectionRequestSort<keyof T> | CollectionRequestSort<keyof T>[], sortables: Partial<Record<ArrayCollectionStringKeys<T>, 'string' | 'number'>>): this;
    toPage(pageNumber: number, pageSize: number): {
        totalPages: number;
        totalEntries: number;
        pageSize: number;
        pageNumber: number;
        data: T[];
    };
    toArray(): T[];
    protected normalizeValueAsString(value: unknown): string;
}

declare class CollectionsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CollectionsModule, never, [typeof BbCollectionsViewer, typeof BbCollectionsPager, typeof BbCollectionsTable, typeof BbCollectionsTableSorting, typeof BbCollectionsTableLabel, typeof BbCollectionsGrid, typeof BbCollectionsActions, typeof BbCollectionsData, typeof BbCollectionsDataRow, typeof BbCollectionsEmpty, typeof BbCollectionsError, typeof BbCollectionsInitial, typeof BbCollectionsItem], [typeof BbCollectionsViewer, typeof BbCollectionsPager, typeof BbCollectionsTable, typeof BbCollectionsTableSorting, typeof BbCollectionsTableLabel, typeof BbCollectionsGrid, typeof BbCollectionsActions, typeof BbCollectionsData, typeof BbCollectionsDataRow, typeof BbCollectionsEmpty, typeof BbCollectionsError, typeof BbCollectionsInitial, typeof BbCollectionsItem]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CollectionsModule>;
}

declare const COLLECTIONS_CONFIG: InjectionToken<CollectionsConfig>;
interface CollectionsConfig {
    icons?: {
        actionsSearch?: string;
        actionsClose?: string;
        pagerArrowPrevious?: string;
        pagerArrowNext?: string;
    };
}

declare function provideCollectionsConfig(config: CollectionsConfig): EnvironmentProviders;

export { ApiCollectionProvider, ArrayCollection, BbCollectionsActions, BbCollectionsData, BbCollectionsDataContext, BbCollectionsDataRow, BbCollectionsDataRowContext, BbCollectionsEmpty, BbCollectionsEmptyContext, BbCollectionsError, BbCollectionsErrorContext, BbCollectionsGrid, BbCollectionsInitial, BbCollectionsInitialContext, BbCollectionsItem, BbCollectionsItemContext, BbCollectionsPager, BbCollectionsTable, BbCollectionsTableLabel, BbCollectionsTableSorting, BbCollectionsViewer, COLLECTIONS_CONFIG, Collection, CollectionProvider, CollectionState, CollectionsModule, LocalCollectionProvider, provideCollectionsConfig };
export type { ArrayCollectionOptions, ArrayCollectionStringKeys, CollectionApiParams, CollectionApiResponse, CollectionContext, CollectionData, CollectionRequest, CollectionRequestSort, CollectionsConfig };