import * as i0 from '@angular/core';
import { OnInit, ElementRef, TemplateRef, EventEmitter, OnDestroy, PipeTransform, InjectionToken, AfterViewInit, Renderer2, ChangeDetectorRef, EnvironmentProviders, ModuleWithProviders } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject } from 'rxjs';
import { FormGroupDirective, NgControl, ValidationErrors, AbstractControl, ControlValueAccessor, FormControl, FormGroup, Validator } from '@angular/forms';
import { ImageConverter } from '@bravobit/bb-foundation';
import { DomSanitizer } from '@angular/platform-browser';
import { Platform } from '@angular/cdk/platform';
import { Localize } from '@bravobit/bb-foundation/localize';

declare class BbFormSubmit implements OnInit {
    private _host;
    private _formDirective;
    submitStatus$: Observable<boolean>;
    constructor(_host: ElementRef<HTMLFormElement>, _formDirective: FormGroupDirective);
    ngOnInit(): void;
    submit(): void;
    reset(): void;
    private get nativeElement();
    private reactiveSubmitChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFormSubmit, [null, { optional: true; self: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbFormSubmit, "form", ["bbForm"], {}, {}, never, never, true, never>;
}

declare class BbFormSubmitter {
    submitted$: BehaviorSubject<boolean>;
    submit(): void;
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFormSubmitter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbFormSubmitter, "[bbFormSubmitter]", ["bbFormSubmitter"], {}, {}, never, never, true, never>;
}

declare class BbFormControl {
    readonly labelId: string;
    ngControl: NgControl;
    label: string | TemplateRef<any> | null;
    hint: string | TemplateRef<any> | null;
    grouped: boolean;
    hideErrors: boolean;
    error: boolean;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFormControl, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbFormControl, "bb-form-control", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "hideErrors": { "alias": "hideErrors"; "required": false; }; }, {}, ["ngControl"], ["[bbPrefix]", "[bbInput]", "[bbSuffix]"], true, never>;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_hideErrors: unknown;
}

declare class BbInput {
    private _elementRef;
    private _formControl;
    constructor(_elementRef: ElementRef, _formControl: BbFormControl);
    focus(): any;
    get id(): string;
    get required(): boolean;
    set required(value: boolean);
    private _required;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbInput, [null, { optional: true; host: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbInput, "input[bbInput],textarea[bbInput],select[bbInput]", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_required: unknown;
}

declare class BbImageUpload {
    private readonly _files;
    private readonly _platform;
    private readonly _renderer;
    width: number | null;
    height: number | null;
    mode: 'aspect-fit' | 'aspect-fill';
    type: 'png' | 'jpg';
    onDataUri: EventEmitter<string>;
    onFile: EventEmitter<File>;
    onClick(): Promise<void>;
    private openFilePicker;
    private toDataUri;
    private toImage;
    private scaleImage;
    private getExportType;
    private getScaleByMode;
    private getFileName;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbImageUpload, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbImageUpload, "button[bbImageUpload]", never, { "width": { "alias": "bbImageUploadWidth"; "required": false; }; "height": { "alias": "bbImageUploadHeight"; "required": false; }; "mode": { "alias": "bbImageUploadMode"; "required": false; }; "type": { "alias": "bbImageUploadType"; "required": false; }; }, { "onDataUri": "onDataUri"; "onFile": "onFile"; }, never, never, true, never>;
    static ngAcceptInputType_width: unknown;
    static ngAcceptInputType_height: unknown;
}

declare class BbExtraErrorControls implements OnDestroy {
    readonly changes: BehaviorSubject<ValidationErrors>;
    private _subscription;
    set extraControls(controls: AbstractControl[]);
    ngOnDestroy(): void;
    private handle;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbExtraErrorControls, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbExtraErrorControls, "[bbExtraErrorControls]", never, { "extraControls": { "alias": "bbExtraErrorControls"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BbFileDrop {
    disabled: boolean;
    onFileDropped: EventEmitter<File[]>;
    hovered: boolean;
    onDrag(event: Event, isHovered: boolean): void;
    onDrop(event: Event): void;
    private setHovered;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFileDrop, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbFileDrop, "[bbFileDrop]", never, { "disabled": { "alias": "bbFileDropDisabled"; "required": false; }; }, { "onFileDropped": "bbFileDrop"; }, never, never, true, never>;
    static ngAcceptInputType_disabled: unknown;
}

declare class ColorPickerDirective implements OnInit, OnDestroy {
    private readonly _overlay;
    private readonly _viewContainerRef;
    private readonly _elementRef;
    private readonly _environmentInjector;
    bbColorPicker: string;
    bbColorPickerShowAlpha: boolean;
    bbColorPickerDisabled: boolean;
    bbColorPickerChange: EventEmitter<string>;
    private _overlayRef;
    private _subscription;
    showColorPicker(): void;
    hideColorPicker(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private attachColorPicker;
    private getPositionStrategy;
    private handleOverlayEvents;
    private createOverlay;
    private getPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ColorPickerDirective, "[bbColorPicker]", never, { "bbColorPicker": { "alias": "bbColorPicker"; "required": true; }; "bbColorPickerShowAlpha": { "alias": "bbColorPickerShowAlpha"; "required": false; }; "bbColorPickerDisabled": { "alias": "bbColorPickerDisabled"; "required": false; }; }, { "bbColorPickerChange": "bbColorPickerChange"; }, never, never, true, never>;
    static ngAcceptInputType_bbColorPickerShowAlpha: unknown;
    static ngAcceptInputType_bbColorPickerDisabled: unknown;
}

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

declare class BbFileImage implements PipeTransform {
    private _platform;
    private _image;
    private _sanitizer;
    constructor(_platform: Platform, _image: ImageConverter, _sanitizer: DomSanitizer);
    transform(file: File): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFileImage, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BbFileImage, "bbFileImage", true>;
}

declare class BbFileDataUrl implements PipeTransform {
    private readonly _platform;
    private readonly _exif;
    private readonly _fileLoader;
    transform(input: File | Blob): Promise<string>;
    private stripExif;
    private isFileLike;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFileDataUrl, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BbFileDataUrl, "bbFileDataUrl", true>;
}

declare class BbRelativeTime implements PipeTransform {
    private _localeId;
    private _localize?;
    constructor(_localeId: string, _localize?: Localize);
    transform(value: string | number | Date): string | number | Date;
    private format;
    private formatString;
    private get locale();
    private isValidDate;
    private parseAsDate;
    private isToday;
    private isYesterday;
    private isTomorrow;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbRelativeTime, [null, { optional: true; }]>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BbRelativeTime, "bbRelativeTime", true>;
}

declare class BbDate implements PipeTransform {
    private readonly _localize;
    private readonly _localeId;
    transform(value: string | number | Date, format?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbDate, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BbDate, "bbDate", true>;
}

declare class BbSpinner {
    readonly color: i0.InputSignal<string>;
    readonly alt: i0.InputSignal<string>;
    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbSpinner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbSpinner, "bb-spinner", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["img", "*"], true, never>;
}

declare class BbButton {
    protected elementRef: ElementRef<HTMLButtonElement>;
    disabled: boolean;
    loading: boolean;
    constructor(elementRef: ElementRef<HTMLButtonElement>);
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbButton, "button[bb-button]", ["bbButton"], { "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[prefix]", "*", "[suffix]"], true, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_loading: unknown;
}
declare class BbAnchor extends BbButton {
    protected elementRef: ElementRef;
    tabIndex: number | null;
    constructor(elementRef: ElementRef);
    stopDisabledEvents(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbAnchor, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbAnchor, "a[bb-button]", ["bbButton", "bbAnchor"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, ["[prefix]", "*", "[suffix]"], true, never>;
}

declare const ELEMENTS_CONFIG: InjectionToken<ElementsConfig>;
declare const ELEMENTS_ICONS: InjectionToken<ElementsIcon[]>;
declare const ELEMENTS_ERRORS: InjectionToken<ElementsError[]>;
type ElementsIcon = ElementsIconFont | ElementsIconImage | ElementsIconUrl | ElementsIconUnknown;
type ElementsError = {
    [error: string]: (data?: any) => string | {
        token: string;
        data?: any;
    };
};
interface ElementsIconFont {
    namespace: string;
    className: string;
    uses: 'content' | 'data-attribute';
    type: 'font';
}
interface ElementsIconImage {
    namespace: string;
    name: string;
    src: string;
    type: 'image';
}
interface ElementsIconUrl {
    namespace: string;
    url: string;
    type: 'url';
}
interface ElementsIconUnknown {
    type: 'unknown';
}
interface ElementsConfig {
    useMaterialDesignIcons?: boolean;
    iconFonts?: ElementsIcon[];
    errors?: ElementsError;
    defaultDisplayUnit?: ElementsDisplayUnit;
    allowedFileTypes?: string[];
    maxFileSize?: number;
    maxTotalFileSize?: number;
    avatarColorAlgorithm?: ElementsAvatarColorAlgorithm;
}
type ElementsDisplayUnit = 'rem' | 'px';
type ElementsAvatarColorAlgorithm = (value: string) => {
    color: string;
    background: string;
} | null;

declare class BbIcon {
    private _config?;
    private _registry?;
    private _src;
    state$: BehaviorSubject<any>;
    alt: string | null;
    size: number;
    ariaHidden: boolean;
    unit: ElementsDisplayUnit | null;
    set src(newValue: string | null);
    get src(): string | null;
    get sizes(): string;
    constructor(_config?: ElementsConfig, _registry?: ElementsIcon[]);
    private convert;
    private findImageIcon;
    private findUrlIcon;
    private findFontIcon;
    private warn;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbIcon, [{ optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbIcon, "bb-icon", never, { "alt": { "alias": "alt"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "src": { "alias": "src"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_size: unknown;
    static ngAcceptInputType_ariaHidden: unknown;
}

declare class BbFormGroup {
    readonly grouped: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFormGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbFormGroup, "bb-form-group", never, { "grouped": { "alias": "grouped"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class BbFormError implements OnInit {
    private _form?;
    private _ngControl?;
    private _formSubmitter?;
    private _extraErrorControls?;
    private _errors?;
    readonly errorsMap: ElementsError;
    control: NgControl | null;
    errorChange: EventEmitter<{
        token: string;
        data?: any;
    }>;
    error$: Observable<{
        token: string;
        data?: any;
    } | null>;
    constructor(_form?: BbFormSubmit, _ngControl?: NgControl, _formSubmitter?: BbFormSubmitter, _extraErrorControls?: BbExtraErrorControls, _errors?: ElementsError[]);
    ngOnInit(): void;
    private setControl;
    private setError;
    private formatError;
    private submitStatusChanges;
    private getNativeFormSubmit;
    private getManualFormSubmit;
    private getErrors;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFormError, [{ optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbFormError, "bb-form-error", never, { "control": { "alias": "control"; "required": false; }; }, { "errorChange": "errorChange"; }, never, never, true, never>;
}

declare class BbCheckbox implements AfterViewInit, ControlValueAccessor {
    private _renderer;
    private _changeDetectorRef;
    readonly labelId: string;
    inputElementRef: ElementRef<HTMLInputElement>;
    checked: boolean;
    indeterminate: boolean;
    disabled: boolean;
    grouped: boolean;
    hideText: boolean;
    checkedChange: EventEmitter<boolean>;
    indeterminateChange: EventEmitter<boolean>;
    onTouchedCallback: () => void;
    onChangeCallback: (_: boolean | null) => void;
    constructor(_renderer: Renderer2, _changeDetectorRef: ChangeDetectorRef);
    ngAfterViewInit(): void;
    toggle(): void;
    writeValue(newValue: boolean): void;
    registerOnChange(method: (_: boolean | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onClickEvent(event: Event): void;
    onChangeEvent(event: Event): void;
    private emitChangeEvent;
    private syncField;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCheckbox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCheckbox, "bb-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "hideText": { "alias": "hideText"; "required": false; }; }, { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, ["*"], true, never>;
    static ngAcceptInputType_checked: unknown;
    static ngAcceptInputType_indeterminate: unknown;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_hideText: unknown;
}

declare class BbCheckboxGroup {
    readonly label: i0.InputSignal<string | TemplateRef<any>>;
    readonly required: i0.InputSignalWithTransform<boolean, unknown>;
    readonly grouped: i0.InputSignalWithTransform<boolean, unknown>;
    readonly inline: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbCheckboxGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbCheckboxGroup, "bb-checkbox-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "grouped": { "alias": "grouped"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; }, {}, never, ["bb-checkbox"], true, never>;
}

declare class BbRadioGroup<T> implements ControlValueAccessor {
    private _changeDetectorRef;
    label: string | TemplateRef<any> | null;
    disabled: boolean;
    readonly: boolean;
    required: boolean;
    grouped: boolean;
    inline: boolean;
    hideErrors: boolean;
    valueChange: EventEmitter<T>;
    get value(): T;
    set value(value: T);
    private _value;
    onTouchedCallback: () => void;
    onChangeCallback: (_: T | null) => void;
    error: boolean;
    constructor(_changeDetectorRef: ChangeDetectorRef);
    select(value: any): void;
    registerOnChange(fn: (newValue: T) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    writeValue(newValue: T): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbRadioGroup<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbRadioGroup<any>, "bb-radio-group", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "hideErrors": { "alias": "hideErrors"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["bb-radio-button"], true, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_readonly: unknown;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_inline: unknown;
    static ngAcceptInputType_hideErrors: unknown;
}

declare class BbRadioButton<T> {
    private readonly _radioGroup?;
    value: T | null;
    hideText: boolean;
    set disabled(value: boolean);
    get disabled(): boolean;
    private _disabled;
    onClick(): void;
    onSpacePressed(): void;
    get selected(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbRadioButton<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbRadioButton<any>, "bb-radio-button", never, { "value": { "alias": "value"; "required": false; }; "hideText": { "alias": "hideText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_hideText: unknown;
    static ngAcceptInputType_disabled: unknown;
}

declare function avatarColorAlgorithm(value: string): {
    color: string;
    background: string;
};
declare class BbAvatar {
    private readonly _config?;
    readonly size: i0.InputSignalWithTransform<number, unknown>;
    readonly unit: i0.InputSignal<ElementsDisplayUnit>;
    readonly src: i0.InputSignal<string>;
    readonly title: i0.InputSignal<string>;
    readonly color: i0.Signal<string>;
    readonly backgroundColor: i0.Signal<string>;
    readonly visualSize: i0.Signal<string>;
    readonly fontSize: i0.Signal<string>;
    readonly initials: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbAvatar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbAvatar, "bb-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface BbMultiFileControlItem {
    id: number;
    label: string;
    url: string;
    description?: string;
}
type BbMultiFileControlOpenEvent = {
    type: 'item';
    item: BbMultiFileControlItem;
} | {
    type: 'file';
    file: File;
};
declare class BbMultiFileControl implements ControlValueAccessor {
    private readonly _files;
    readonly labelId: string;
    readonly fileInputRef: i0.Signal<ElementRef<HTMLInputElement>>;
    readonly appearance: i0.InputSignal<"multiple" | "single">;
    readonly label: i0.InputSignal<string | TemplateRef<any>>;
    readonly hint: i0.InputSignal<string | TemplateRef<any>>;
    readonly accept: i0.InputSignal<string>;
    readonly maxFileSize: i0.InputSignalWithTransform<number, unknown>;
    readonly maxTotalFileSize: i0.InputSignalWithTransform<number, unknown>;
    readonly grouped: i0.InputSignalWithTransform<boolean, unknown>;
    readonly required: i0.InputSignalWithTransform<boolean, unknown>;
    readonly hideErrors: i0.InputSignalWithTransform<boolean, unknown>;
    readonly disabled: i0.ModelSignal<boolean>;
    readonly items: i0.ModelSignal<BbMultiFileControlItem[]>;
    delete: EventEmitter<BbMultiFileControlItem>;
    open: EventEmitter<BbMultiFileControlOpenEvent>;
    readonly value: i0.WritableSignal<File[]>;
    readonly error: i0.WritableSignal<boolean>;
    readonly showList: i0.Signal<boolean>;
    onTouchedCallback: () => void;
    onChangeCallback: (_: File[] | null) => void;
    openItem(event: Event, item: BbMultiFileControlItem): void;
    downloadFile(event: Event, file: File): void;
    openFileDialog(): void;
    onFileChange(event: Event): void;
    deleteFile(index: number): void;
    writeValue(value: File[] | null): void;
    registerOnChange(method: (_: File[] | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    validate(control: FormControl<File[]>): {
        invalidFiles: Record<number, boolean>;
        maxFileSize?: undefined;
        maxTotalFileSize?: undefined;
    } | {
        maxFileSize: {
            maxSize: string;
        };
        invalidFiles?: undefined;
        maxTotalFileSize?: undefined;
    } | {
        maxTotalFileSize: {
            max: string;
            current: string;
        };
        invalidFiles?: undefined;
        maxFileSize?: undefined;
    };
    addFiles(files: File[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbMultiFileControl, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbMultiFileControl, "bb-multi-file-control", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "maxTotalFileSize": { "alias": "maxTotalFileSize"; "required": false; "isSignal": true; }; "grouped": { "alias": "grouped"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hideErrors": { "alias": "hideErrors"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "items": "itemsChange"; "delete": "delete"; "open": "open"; }, never, never, true, never>;
}

declare class BbFilePicker implements ControlValueAccessor {
    readonly labelId: string;
    fileInput: ElementRef<HTMLInputElement>;
    extraTemplate: TemplateRef<any>;
    label: string | TemplateRef<any> | null;
    hint: string | TemplateRef<any> | null;
    accept: string;
    maxFileSize: number;
    showImages: boolean;
    grouped: boolean;
    required: boolean;
    disabled: boolean;
    hideErrors: boolean;
    error: boolean;
    value$: BehaviorSubject<{
        file?: File;
    }>;
    onTouchedCallback: () => void;
    onChangeCallback: (_: File | null) => void;
    get value(): File | null;
    valueChange: EventEmitter<File>;
    set value(value: File | null);
    onButtonPressed(file?: File): void;
    openFilePicker(): void;
    onFileChange(event: Event): void;
    writeValue(value: File | null): void;
    registerOnChange(method: (_: File | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    validate({ value }: FormControl<File>): {
        invalidFileType: boolean;
        maxFileSize?: undefined;
    } | {
        maxFileSize: {
            maxSize: string;
        };
        invalidFileType?: undefined;
    };
    saveFile(files: File[]): void;
    private getFilesFromEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbFilePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbFilePicker, "bb-file-picker", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "showImages": { "alias": "showImages"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hideErrors": { "alias": "hideErrors"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, ["extraTemplate"], never, true, never>;
    static ngAcceptInputType_maxFileSize: unknown;
    static ngAcceptInputType_showImages: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_hideErrors: unknown;
}

declare class BbImagePicker implements ControlValueAccessor {
    private _converter;
    fileInput: ElementRef<HTMLInputElement>;
    label: string | null;
    placeholder: string | null;
    styleDimensions: {
        width: string;
        height: string;
    } | null;
    cropDimensions: {
        width: number;
        height: number;
    } | null;
    buttonClass: string | null;
    disabled: boolean;
    grouped: boolean;
    onTouchedCallback: () => void;
    onChangeCallback: (_: string | null) => void;
    private _value$;
    constructor(_converter: ImageConverter);
    get value(): string | null;
    valueChange: EventEmitter<string>;
    set value(value: string | null);
    get image(): rxjs.Observable<string>;
    onFileChange(event: any): Promise<void>;
    openFilePicker(): void;
    writeValue(value: string | null): void;
    registerOnChange(method: (_: string | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbImagePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbImagePicker, "bb-image-picker", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "styleDimensions": { "alias": "styleDimensions"; "required": false; }; "cropDimensions": { "alias": "cropDimensions"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_grouped: unknown;
}

declare class BbDatePicker implements ControlValueAccessor, OnInit, OnDestroy {
    private _changeDetectorRef;
    private _localizeId;
    readonly _yearRegex: RegExp;
    label: string | TemplateRef<any> | null;
    hint: string | TemplateRef<any> | null;
    dayPlaceholder: string | null;
    monthPlaceholder: string | null;
    yearPlaceholder: string | null;
    required: boolean;
    grouped: boolean;
    readonly: boolean;
    hideErrors: boolean;
    set disabled(value: boolean);
    get disabled(): boolean;
    set years(value: [string | number, string | number] | null);
    form: FormGroup;
    data$: Observable<{
        days?: {
            label: string;
            value: number;
        }[];
        months?: {
            label: string;
            value: number;
        }[];
        years?: number[] | null;
    }>;
    years$: BehaviorSubject<number[]>;
    get value(): string | null;
    set value(value: string | null);
    valueChange: EventEmitter<string>;
    error: boolean;
    private _disabled;
    onTouchedCallback: () => void;
    onChangeCallback: (_: string | null) => void;
    private _subscription;
    constructor(_changeDetectorRef: ChangeDetectorRef, _localizeId: Observable<string>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    writeValue(value: string | null): void;
    registerOnChange(method: (_: string | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    validate({ value }: FormControl<string>): {
        invalidDate: boolean;
    };
    private handleChanges;
    private getData;
    private verifyListData;
    private getDayData;
    private getMonthData;
    private composeForm;
    private parseDateStringInForm;
    private parseDateString;
    private parseYears;
    private formToDateString;
    private parseYearFormat;
    private getDaysInMonth;
    private isValidDateString;
    private padString;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbDatePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbDatePicker, "bb-date-picker", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "dayPlaceholder": { "alias": "dayPlaceholder"; "required": false; }; "monthPlaceholder": { "alias": "monthPlaceholder"; "required": false; }; "yearPlaceholder": { "alias": "yearPlaceholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hideErrors": { "alias": "hideErrors"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "years": { "alias": "years"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_readonly: unknown;
    static ngAcceptInputType_hideErrors: unknown;
    static ngAcceptInputType_disabled: unknown;
}

declare class BbColorSlider implements OnInit, OnDestroy {
    private readonly _elementRef;
    private readonly _document;
    xOffset: number;
    yOffset: number;
    size: number;
    xOffsetChange: EventEmitter<number>;
    yOffsetChange: EventEmitter<number>;
    private _subscription;
    get x(): number;
    get y(): number;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateValue;
    private setOffsets;
    private calculate;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbColorSlider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbColorSlider, "bb-color-slider", never, { "xOffset": { "alias": "xOffset"; "required": false; }; "yOffset": { "alias": "yOffset"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "xOffsetChange": "xOffsetChange"; "yOffsetChange": "yOffsetChange"; }, never, never, true, never>;
    static ngAcceptInputType_xOffset: unknown;
    static ngAcceptInputType_yOffset: unknown;
    static ngAcceptInputType_size: unknown;
}

declare class BbColorPicker {
    showAlpha: boolean;
    set color(value: string);
    get color(): string;
    colorChange: EventEmitter<string>;
    hueOffset: number;
    saturationOffset: number;
    valueOffset: number;
    opacityOffset: number;
    private _color;
    setColor(): void;
    private setUIVariables;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbColorPicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbColorPicker, "bb-color-picker", never, { "showAlpha": { "alias": "showAlpha"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
    static ngAcceptInputType_showAlpha: unknown;
}

declare class BbImageControl implements ControlValueAccessor {
    private readonly _changeDetectorRef;
    readonly labelId: string;
    label: string | TemplateRef<any> | null;
    hint: string | TemplateRef<any> | null;
    buttonLabel: string | null;
    imageUrl: string | null;
    mode: 'aspect-fit' | 'aspect-fill';
    type: 'png' | 'jpg';
    cropWidth: number;
    visualMaxWidth: number | null;
    aspectRatio: number;
    grouped: boolean;
    required: boolean;
    disabled: boolean;
    hideErrors: boolean;
    delete: EventEmitter<void>;
    value: File | null;
    error: boolean;
    onTouchedCallback: () => void;
    onChangeCallback: (_: File | null) => void;
    onFile(file: File): void;
    onDelete(): Promise<void>;
    writeValue(value: File | null): void;
    registerOnChange(method: (_: File | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbImageControl, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbImageControl, "bb-image-control", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "type": { "alias": "type"; "required": false; }; "cropWidth": { "alias": "cropWidth"; "required": false; }; "visualMaxWidth": { "alias": "visualMaxWidth"; "required": false; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hideErrors": { "alias": "hideErrors"; "required": false; }; }, { "delete": "delete"; }, never, ["[suffix]"], true, never>;
    static ngAcceptInputType_cropWidth: unknown;
    static ngAcceptInputType_visualMaxWidth: unknown;
    static ngAcceptInputType_aspectRatio: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_hideErrors: unknown;
}

declare class BbPincodeControl implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private readonly _platform;
    private readonly _changeDetectorRef;
    htmlInputElementRef: ElementRef<HTMLInputElement>;
    label: string | TemplateRef<any> | null;
    hint: string | TemplateRef<any> | null;
    placeholder: string | null;
    autoFocus: boolean;
    required: boolean;
    readonly: boolean;
    grouped: boolean;
    digits: number;
    get value(): string | null;
    valueChange: EventEmitter<string>;
    set value(value: string | null);
    data$: Observable<{
        items?: {
            index: number;
            value: string;
            active: boolean;
        }[];
    }>;
    control: FormControl<string>;
    error: boolean;
    onTouchedCallback: () => void;
    onChangeCallback: (_: string | null) => void;
    private _subscription;
    ngOnInit(): void;
    ngOnDestroy(): void;
    writeValue(value: string | null): void;
    registerOnChange(method: (_: string | null) => void): void;
    registerOnTouched(method: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onErrorChange(error: {
        token: string;
        data?: any;
    } | null): void;
    validate(control: FormControl): {
        maxlength: {
            actualLength: any;
            requiredLength: number;
        };
        minlength?: undefined;
    } | {
        minlength: {
            actualLength: any;
            requiredLength: number;
        };
        maxlength?: undefined;
    };
    focusEnd(): void;
    private setData;
    private handleValueChanges;
    private handleAutoFocus;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbPincodeControl, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BbPincodeControl, "bb-pincode-control", never, { "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "grouped": { "alias": "grouped"; "required": false; }; "digits": { "alias": "digits"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
    static ngAcceptInputType_autoFocus: unknown;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_readonly: unknown;
    static ngAcceptInputType_grouped: unknown;
    static ngAcceptInputType_digits: unknown;
}

declare function injectAcceptString(): string;
declare function injectMaxFileSize(): number;
declare function injectMaxTotalFileSize(): number;

declare function provideElementsConfig(config?: ElementsConfig): EnvironmentProviders;

declare class ElementsModule {
    static forRoot(config?: ElementsConfig): ModuleWithProviders<ElementsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElementsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementsModule, never, [typeof BbFormError, typeof BbFormSubmit, typeof BbFormSubmitter, typeof BbInput, typeof BbImageUpload, typeof BbExtraErrorControls, typeof BbFileDrop, typeof ColorPickerDirective, typeof BbFileSize, typeof BbFileImage, typeof BbRelativeTime, typeof BbDate, typeof BbButton, typeof BbAnchor, typeof BbSpinner, typeof BbIcon, typeof BbFormControl, typeof BbFormGroup, typeof BbCheckbox, typeof BbCheckboxGroup, typeof BbRadioGroup, typeof BbRadioButton, typeof BbAvatar, typeof BbMultiFileControl, typeof BbFilePicker, typeof BbImagePicker, typeof BbDatePicker, typeof BbColorSlider, typeof BbColorPicker, typeof BbImageControl, typeof BbPincodeControl], [typeof BbFormError, typeof BbFormSubmit, typeof BbFormSubmitter, typeof BbInput, typeof BbImageUpload, typeof BbExtraErrorControls, typeof BbFileDrop, typeof ColorPickerDirective, typeof BbFileSize, typeof BbFileImage, typeof BbRelativeTime, typeof BbDate, typeof BbButton, typeof BbAnchor, typeof BbSpinner, typeof BbIcon, typeof BbFormControl, typeof BbFormGroup, typeof BbCheckbox, typeof BbCheckboxGroup, typeof BbRadioGroup, typeof BbRadioButton, typeof BbAvatar, typeof BbMultiFileControl, typeof BbFilePicker, typeof BbImagePicker, typeof BbDatePicker, typeof BbColorSlider, typeof BbColorPicker, typeof BbImageControl, typeof BbPincodeControl]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ElementsModule>;
}

export { BbAnchor, BbAvatar, BbButton, BbCheckbox, BbCheckboxGroup, BbColorPicker, BbColorSlider, BbDate, BbDatePicker, BbExtraErrorControls, BbFileDataUrl, BbFileDrop, BbFileImage, BbFilePicker, BbFileSize, BbFormControl, BbFormError, BbFormGroup, BbFormSubmit, BbFormSubmitter, BbIcon, BbImageControl, BbImagePicker, BbImageUpload, BbInput, BbMultiFileControl, BbPincodeControl, BbRadioButton, BbRadioGroup, BbRelativeTime, BbSpinner, ColorPickerDirective, ELEMENTS_CONFIG, ELEMENTS_ERRORS, ELEMENTS_ICONS, ElementsModule, avatarColorAlgorithm, injectAcceptString, injectMaxFileSize, injectMaxTotalFileSize, provideElementsConfig };
export type { BbMultiFileControlItem, BbMultiFileControlOpenEvent, ElementsAvatarColorAlgorithm, ElementsConfig, ElementsDisplayUnit, ElementsError, ElementsIcon, ElementsIconFont, ElementsIconImage, ElementsIconUnknown, ElementsIconUrl };