@bravobit/bb-foundation 0.54.3 → 0.55.0

package/auth/index.d.ts

@@ -1,5 +1,267 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@bravobit/bb-foundation/auth" />
-export * from './public_api';
+import { ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, CanActivateFn } from '@angular/router';
+import { StorageOption, StorageStrategy } from '@bravobit/bb-foundation/storage';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, TemplateRef, EnvironmentProviders, ModuleWithProviders } from '@angular/core';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpClient, HttpContextToken, HttpInterceptor, HttpRequest, HttpHandler, HttpHeaders, HttpParams } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+
+interface AuthToken {
+    id?: string;
+    type?: string;
+    audience?: string;
+    issuer?: string;
+    subject?: string;
+    notValidBefore?: Date;
+    expiresAt?: Date;
+    issuedAt?: Date;
+    role?: string;
+}
+
+type AuthStrategy = 'httpOnlyCookie' | 'browserStorage';
+interface AuthConfig {
+    applicationId: string;
+    strategy: AuthStrategy;
+    preferredStorageOptions?: StorageOption[];
+    http?: {
+        scheme?: string;
+        header?: string;
+    };
+    redirects?: {
+        authenticated?: string | string[];
+        unauthenticated?: string | string[];
+    };
+    setRedirectOnFailedAuth?: boolean;
+    interceptActing?: boolean;
+    providers?: string[];
+    autoRefresh?: boolean;
+}
+declare const AUTH_CONFIG: InjectionToken<AuthConfig>;
+declare const AUTH_REDIRECT_HANDLER: InjectionToken<AuthRedirectHandler>;
+interface AuthRedirectHandler {
+    onFailedAuthenticated(snapshot?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): boolean | UrlTree;
+    onFailedAnonymous(snapshot?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): boolean | UrlTree;
+}
+
+interface AuthProvider {
+    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
+}
+interface AuthProviderResponse {
+    token: string;
+    refresh_token?: string;
+    provider?: string;
+    verify_token?: string;
+    user?: any;
+}
+interface AuthProviderResult {
+    accessToken?: string;
+    refreshToken?: string;
+    provider?: string;
+    verifyToken?: string;
+    user?: any;
+}
+interface AuthSignInResponse {
+    user?: unknown;
+    provider?: string;
+    verifyToken?: string;
+}
+
+declare const USE_AUTHORIZATION: HttpContextToken<boolean>;
+
+declare class JwtHelper {
+    decode(token: string): AuthToken;
+    private urlDecode;
+    private baseDecodeUnicode;
+    private parse;
+    private parseDate;
+}
+
+declare class BbAuthenticated implements OnInit, OnDestroy {
+    private readonly _auth;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _valid;
+    private _elseTemplateRef;
+    private _thenViewRef;
+    private _elseViewRef;
+    private _subscription;
+    set bbAuthenticatedElse(templateRef: TemplateRef<any>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateView;
+    private assertTemplate;
+    static ngAcceptInputType_bbAuthenticatedElse: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BbAuthenticated, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BbAuthenticated, "ng-template[bbAuthenticated]", never, { "bbAuthenticatedElse": { "alias": "bbAuthenticatedElse"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BbAnonymous implements OnInit, OnDestroy {
+    private readonly _auth;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _valid;
+    private _elseTemplateRef;
+    private _thenViewRef;
+    private _elseViewRef;
+    private _subscription;
+    set bbAnonymousElse(templateRef: TemplateRef<any>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateView;
+    private assertTemplate;
+    static ngAcceptInputType_bbAnonymousElse: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BbAnonymous, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BbAnonymous, "ng-template[bbAnonymous]", never, { "bbAnonymousElse": { "alias": "bbAnonymousElse"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const bbAnonymousGuard: CanActivateFn;
+
+declare const bbAuthenticatedGuard: CanActivateFn;
+
+declare class AuthEmailProvider implements AuthProvider {
+    private _email;
+    private _password;
+    private _endpoint;
+    constructor(_email: string, _password: string, _endpoint: string);
+    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
+}
+
+declare class AuthVerifyProvider implements AuthProvider {
+    private _code;
+    private _verifyToken;
+    private _endpoint;
+    constructor(_code: string, _verifyToken: string, _endpoint: string);
+    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
+}
+
+declare class Acting {
+    private readonly _auth;
+    private _userId$;
+    readonly info$: Observable<{
+        active?: boolean;
+        user?: any;
+    }>;
+    start(userId: number): Promise<void>;
+    stop(): Promise<void>;
+    getCurrent(): number;
+    private fetchUserDetails;
+    private getInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Acting, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Acting>;
+}
+
+declare class ActingInterceptor implements HttpInterceptor {
+    private readonly _acting;
+    private readonly _headerString;
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActingInterceptor>;
+}
+
+declare class AuthSession {
+    private readonly _jwt;
+    private readonly _storage;
+    private readonly _accessTokenStorageKey;
+    private readonly _refreshTokenStorageKey;
+    private readonly _authenticatedStorageKey;
+    private readonly _strategy;
+    private _authenticated;
+    private _accessTokenString;
+    private _refreshTokenString;
+    private _accessTokenPayload;
+    private _refreshTokenPayload;
+    private _user$;
+    user: rxjs.Observable<any>;
+    constructor(options?: {
+        id?: string;
+        storage?: StorageStrategy;
+        strategy?: AuthStrategy;
+    });
+    get snapshot(): {
+        user: any;
+        accessToken?: undefined;
+        refreshToken?: undefined;
+    } | {
+        user: any;
+        accessToken: string;
+        refreshToken: string;
+    };
+    get accessToken(): string;
+    get refreshToken(): string;
+    get accessTokenPayload(): AuthToken;
+    get refreshTokenPayload(): AuthToken;
+    authenticated(): boolean;
+    setTokens(accessToken: string | null, refreshToken: string | null, persist?: boolean): void;
+    setUser(user: unknown, persist?: boolean): void;
+    clear(): void;
+    private restoreFromStorage;
+    private persistTokensInStorage;
+    private persistAuthenticatedInStorage;
+    private setAuthenticated;
+    private cacheAccessToken;
+    private cacheRefreshToken;
+    private cacheAuthenticated;
+    private generateKey;
+    private isTokenValid;
+    private getNextYearDate;
+}
+
+declare class Auth {
+    private readonly _storage;
+    private readonly _injector;
+    private readonly _platform;
+    private readonly _httpClient;
+    private readonly _state?;
+    private readonly _config?;
+    private readonly _httpConfig?;
+    private readonly _handler?;
+    private readonly _authStateKey;
+    private readonly _httpAlias;
+    readonly session: AuthSession;
+    readonly user: Observable<any | null>;
+    private _refreshHandler;
+    constructor();
+    initialize(): Promise<void>;
+    me<T = any>(): Observable<T>;
+    signIn<T = any>(provider: AuthProvider, verify?: (user: T) => void): Promise<AuthSignInResponse>;
+    signInWithEmail<T = any>(email: string, password: string, verify?: (user: T) => void): Promise<AuthSignInResponse>;
+    signInWithVerifyCode(code: string, verifyToken: string): Promise<AuthSignInResponse>;
+    resendVerifyCode(verifyToken: string): Promise<Object>;
+    register<T = any>(data: any, options?: {
+        headers?: HttpHeaders | {
+            [header: string]: string | string[];
+        };
+        params?: HttpParams | {
+            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+        };
+    }): Promise<T>;
+    logout(): void;
+    refresh(): Observable<string>;
+    requestPassword(email: string, extraParams?: {
+        [key: string]: any;
+    }): Promise<Object>;
+    resetPassword(token: string, newPassword: string, extraParams?: {
+        [key: string]: any;
+    }): Promise<Object>;
+    clearAndRedirect(): void;
+    private setTokens;
+    private handleAutoRefreshing;
+    private autoRefresh;
+    private get router();
+    private getUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Auth, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Auth>;
+}
+
+declare function provideAuthConfig(config?: AuthConfig): EnvironmentProviders;
+
+declare class AuthModule {
+    static forRoot(config: AuthConfig): ModuleWithProviders<AuthModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AuthModule, never, [typeof BbAuthenticated], [typeof BbAuthenticated]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AuthModule>;
+}
+
+export { AUTH_CONFIG, AUTH_REDIRECT_HANDLER, Acting, ActingInterceptor, Auth, AuthEmailProvider, AuthModule, AuthSession, AuthVerifyProvider, BbAnonymous, BbAuthenticated, JwtHelper, USE_AUTHORIZATION, bbAnonymousGuard, bbAuthenticatedGuard, provideAuthConfig };
+export type { AuthConfig, AuthProvider, AuthProviderResponse, AuthProviderResult, AuthRedirectHandler, AuthSignInResponse, AuthStrategy, AuthToken };

package/collections/index.d.ts

@@ -1,5 +1,350 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@bravobit/bb-foundation/collections" />
-export * from './public_api';
+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;
+    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; }; "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 };