import { BooleanInput } from '@angular/cdk/coercion';
import * as i0 from '@angular/core';
import { OnDestroy, ChangeDetectorRef, Type, Provider, TemplateRef, ViewContainerRef, ElementRef, OnInit, AfterContentInit, QueryList, EventEmitter, InjectionToken } from '@angular/core';
import { MapEmit } from '@k5cjs/selection-model';
import { Subject, Observable } from 'rxjs';
import * as i18 from '@angular/cdk/overlay';
import { CdkOverlayOrigin, OverlayConfig, ConnectedPosition, Overlay } from '@angular/cdk/overlay';
import { ConfigurableFocusTrapFactory } from '@angular/cdk/a11y';
import { ControlValueAccessor } from '@angular/forms';
import { KcControl, KcControlType } from '@k5cjs/control';
import * as i17 from '@angular/common';

type Options<V, K, L> = KcOption<V, K, L>[] | KcOption<V, K, L>[][] | KcGroup<V, K, L>;
type Value<V> = KcOptionValue<V> | KcOptionGroupValue<V>;
declare const getSelectedOptions: <V, K, L>(options: Options<V, K, L>, value: Value<V> | undefined) => [K | V, KcOption<V, K, L>][] | undefined;

type OptionsValue<V> = KcOptionGroupValue<V> | KcOptionValue<V>;
declare function getValues<V, K, L>(values: KcOptionSelection<V, K, L>): OptionsValue<V> | undefined;

declare const isOptionChunks: <V, K, L>(option: KcOption<V, K, L>[] | KcOption<V, K, L>[][] | KcGroup<V, K, L>) => option is KcOption<V, K, L>[][];

declare class MapEmitSelect<V, K = V, T extends boolean = false> extends MapEmit<K, V, T> {
    constructor(multiple: T, initiallyValues?: T extends false ? [K, V] : [K, V][]);
    get test(): T extends false ? V | null : V[];
    private _isMapEmitSelect;
    private _isUnion;
}

declare class KcOptionComponent<V, K, L> implements OnDestroy {
    protected _selection: MapEmitSelect<KcOption<V, K, L>, K | V, boolean>;
    protected _cdr: ChangeDetectorRef;
    option: KcOption<V, K, L>;
    protected _destroy: Subject<void>;
    constructor(_selection: MapEmitSelect<KcOption<V, K, L>, K | V, boolean>, _cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    get selected(): boolean;
    click(): void;
    toggle(): void;
    select(): void;
    deselect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcOptionComponent<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KcOptionComponent<any, any, any>, "kc-option", never, { "option": { "alias": "option"; "required": false; }; }, {}, never, never, false, never>;
}

declare function provideKcOption<T extends KcOptionComponent<unknown, unknown, unknown>>(type: Type<T>): Provider;

declare function filterNestedOptions(options: KcOption<string, string>[], search: string): KcOption<string, string>[];
declare function filterNestedOptions(options: KcOption<string, string>[][], search: string): KcOption<string, string>[][];
declare function filterNestedOptions(options: KcGroup<string, string>, search: string): KcGroup<string, string>;

/**
 * options type for input options
 */

interface KcOption<V, K = V, L = string> {
    value: V;
    key?: K;
    label?: L;
    compareFn?: (selectedOption: V | KcOptionGroupValue<V>, currentOption: V) => boolean;
}
type KcGroup<V, K = V, L = string> = {
    [K: string]: KcGroup<V, K, L> | OptionGroup<V, K, L>;
};
interface OptionGroup<V, K = V, L = string> {
    value: KcOption<V, K, L>[] | KcOption<V, K, L>[][];
    label?: string;
}
/**
 * options type for output options
 */
type KcOptionValue<V> = V | V[];
type KcOptionGroupValue<V> = {
    [K: string]: KcOptionValue<V> | KcOptionGroupValue<V>;
};
/**
 * options for internal structure
 */
type KcOptionSelection<V, K, L> = MapEmitSelect<KcOption<V, K, L> | KcOptionSelection<V, K, L>, string | V | K, boolean>;

interface KcSelect<V = unknown> {
    allSelected: boolean;
    allSelectedChanged: Observable<boolean>;
    multiple: boolean;
    focused: boolean;
    click: (event: MouseEvent) => void;
    open: (event?: MouseEvent) => void;
    close: (event?: MouseEvent) => void;
    submit: () => void;
    selectAll: () => void;
    deselectAll: () => void;
    toggle: () => void;
    clear: () => void;
    get value(): KcOptionValue<V> | KcOptionGroupValue<V>;
}

declare class KcClearDirective {
    private _kcSelect;
    constructor(_kcSelect: KcSelect);
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcClearDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcClearDirective, "[kcClear]", never, {}, {}, never, never, false, never>;
}

declare class KcCloseDirective {
    private _kcSelect;
    kcClose: boolean;
    constructor(_kcSelect: KcSelect);
    onClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcCloseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcCloseDirective, "[kcClose]", never, { "kcClose": { "alias": "kcClose"; "required": false; }; }, {}, never, never, false, never>;
    static ngAcceptInputType_kcClose: any;
}

declare class KcDeselectAllDirective {
    private _kcSelect;
    constructor(_kcSelect: KcSelect);
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcDeselectAllDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcDeselectAllDirective, "[kcDeselectAll]", never, {}, {}, never, never, false, never>;
}

type Context$2<V, K, L> = {
    $implicit: KcGroup<V, K, L>;
};
declare class KcGroupDirective<V, K, L> {
    private _template;
    private _viewContainer;
    private _cdr;
    private _embeddedViewRef;
    constructor(_template: TemplateRef<Context$2<V, K, L>>, _viewContainer: ViewContainerRef, _cdr: ChangeDetectorRef);
    static ngTemplateContextGuard<V, K, L>(_dir: KcGroupDirective<V, K, L>, _ctx: Context$2<V, K, L>): _ctx is Context$2<V, K, L>;
    render(options: KcGroup<V, K, L>): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcGroupDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcGroupDirective<any, any, any>, "[kcGroup]", never, {}, {}, never, never, false, never>;
}

type Context$1<V, K, L> = {
    $implicit: KcOption<V, K, L>;
};
declare class KcOptionDirective<V, K, L> {
    template: TemplateRef<Context$1<V, K, L>>;
    type: KcOption<V, K, L>;
    constructor(template: TemplateRef<Context$1<V, K, L>>);
    static ngTemplateContextGuard<V, K, L>(_dir: KcOptionDirective<V, K, L>, _ctx: Context$1<V, K, L>): _ctx is Context$1<V, K, L>;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcOptionDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcOptionDirective<any, any, any>, "[kcOption]", never, { "type": { "alias": "kcOptionType"; "required": false; }; }, {}, never, never, false, never>;
}

type Context<V, K, L> = {
    $implicit: KcOption<V, K, L>[];
};
declare class KcOptionsDirective<V, K, L> {
    private _template;
    private _viewContainer;
    private _cdr;
    type: KcOption<V, K, L>;
    private _embeddedViewRef;
    constructor(_template: TemplateRef<Context<V, K, L>>, _viewContainer: ViewContainerRef, _cdr: ChangeDetectorRef);
    static ngTemplateContextGuard<V, K, L>(_dir: KcOptionsDirective<V, K, L>, _ctx: Context<V, K, L>): _ctx is Context<V, K, L>;
    render(options: KcOption<V, K, L>[]): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcOptionsDirective<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcOptionsDirective<any, any, any>, "[kcOptions]", never, { "type": { "alias": "kcOptionsType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class KcOriginDirective extends CdkOverlayOrigin {
    elementRef: ElementRef<HTMLElement>;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcOriginDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcOriginDirective, "[kcOrigin]", ["kcOrigin"], {}, {}, never, never, false, never>;
}

declare class KcSelectAllDirective {
    private _kcSelect;
    constructor(_kcSelect: KcSelect);
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcSelectAllDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcSelectAllDirective, "[kcSelectAll]", never, {}, {}, never, never, false, never>;
}

declare class KcSubmitDirective {
    private _kcSelect;
    constructor(_kcSelect: KcSelect);
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcSubmitDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcSubmitDirective, "[kcSubmit]", never, {}, {}, never, never, false, never>;
}

declare class KcToggleDirective {
    private _kcSelect;
    constructor(_kcSelect: KcSelect);
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcToggleDirective, "[kcToggle]", never, {}, {}, never, never, false, never>;
}

declare class KcValueDirective {
    template: TemplateRef<unknown>;
    private _cdr;
    constructor(template: TemplateRef<unknown>, _cdr: ChangeDetectorRef);
    render(viewContainer: ViewContainerRef): void;
    clear(viewContainer: ViewContainerRef): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KcValueDirective, "[kcValue]", never, {}, {}, never, never, false, never>;
}

declare class KcGroupComponent<V, K, L> implements OnInit, AfterContentInit, OnDestroy {
    private _selection;
    private _select;
    get options(): KcGroup<V, K, L>;
    set options(options: KcGroup<V, K, L>);
    private _options;
    key: string;
    get multiple(): boolean;
    set multiple(value: BooleanInput);
    private _multiple;
    groups: QueryList<KcGroupDirective<V, K, L>>;
    option: QueryList<KcOptionsDirective<V, K, L>>;
    selection: MapEmitSelect<KcOption<V, K, L> | KcOptionSelection<V, K, L>, string | K | V, boolean>;
    private _destroy;
    constructor(_selection: MapEmitSelect<KcOptionSelection<V, K, L>, string, boolean>, _select: KcSelect<V>);
    get value(): KcOptionValue<V> | KcOptionGroupValue<V>;
    ngAfterContentInit(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _initSelection;
    private _render;
    private _getSelection;
    private _getOption;
    private _getGroup;
    private _getOptionGroup;
    private _getOptions;
    private _isOptionGroup;
    private _isOptionGroupValue;
    private _isOptionChunks;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcGroupComponent<any, any, any>, [{ skipSelf: true; }, { skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KcGroupComponent<any, any, any>, "kc-group", never, { "options": { "alias": "options"; "required": false; }; "key": { "alias": "key"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, {}, ["groups", "option"], ["*", "[footer]"], false, never>;
}

declare class KcOptionsComponent<V, K, L> {
    get options(): KcOption<V, K, L>[];
    set options(options: KcOption<V, K, L>[]);
    private _options;
    /**
     *  { static: true } needs to be set when you want to access the ViewChild in ngOnInit.
     */
    optionTemplate: KcOptionDirective<V, K, L>;
    protected _outlet: ViewContainerRef;
    protected _render(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcOptionsComponent<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KcOptionsComponent<any, any, any>, "kc-options", never, { "options": { "alias": "options"; "required": false; }; }, {}, ["optionTemplate"], ["*", "[footer]"], false, never>;
}

declare class KcValueComponent<T extends boolean = false> {
    private _selection;
    value: Observable<string | undefined>;
    constructor(_selection: MapEmitSelect<KcOption<string, unknown>, string, T>);
    get preventClose(): boolean;
    removeTag(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcValueComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KcValueComponent<any>, "kc-value", never, {}, {}, never, ["*", "*"], false, never>;
}

declare class KcSelectComponent<V, K, L> extends KcControl<KcOptionValue<V> | KcOptionGroupValue<V>> implements OnInit, AfterContentInit, ControlValueAccessor, KcSelect, KcControlType<KcOptionValue<V> | KcOptionGroupValue<V>> {
    private _overlay;
    private _viewContainerRef;
    private _cdr;
    private _trap;
    get options(): Observable<KcOption<V, K, L>[] | KcOption<V, K, L>[][] | KcGroup<V, K, L>>;
    set options(options: Observable<KcOption<V, K, L>[] | KcOption<V, K, L>[][] | KcGroup<V, K, L>> | KcOption<V, K, L>[] | KcOption<V, K, L>[][] | KcGroup<V, K, L>);
    private _options;
    private _optionsCache;
    /**
     * allow user to open selection in modal
     */
    get multiple(): boolean;
    set multiple(value: boolean | string);
    private _multiple;
    /**
     * allow user to open selection in modal
     */
    get dialog(): boolean;
    set dialog(value: boolean | string);
    private _dialog;
    /**
     * allow user to change origin from where selection will be opened
     */
    origin: KcOriginDirective | undefined;
    cdkOverlayConfig: OverlayConfig;
    positions: ConnectedPosition[];
    closed: EventEmitter<KcOptionValue<V> | KcOptionGroupValue<V>>;
    submitted: EventEmitter<KcOptionValue<V> | KcOptionGroupValue<V>>;
    private _valueRef;
    templateRef: TemplateRef<unknown>;
    optionComponents: QueryList<KcOptionComponent<V, K, L>>;
    private _valueDirective?;
    private _groupDirectives;
    private _optionsDirectives;
    set value(val: KcOptionValue<V> | KcOptionGroupValue<V>);
    get value(): KcOptionValue<V> | KcOptionGroupValue<V>;
    private _value;
    /**
     * selectionOpened variable is for check if the overlay or dialog is open
     */
    selectionOpened: boolean;
    selection: KcOptionSelection<V, K, L>;
    allSelected: boolean;
    allSelectedChanged: Observable<boolean>;
    private _allSelectedChanged;
    private _dialogOverlayRef;
    private _tabIndex;
    private _subscriptionOptions?;
    private _subscriptionChanges?;
    constructor(_overlay: Overlay, _viewContainerRef: ViewContainerRef, _cdr: ChangeDetectorRef, _trap: ConfigurableFocusTrapFactory, tabIndex: string);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    writeValue(obj: KcOptionValue<V> | KcOptionGroupValue<V>): void;
    /**
     * allow element to be focusable
     */
    get tabindex(): number;
    protected _keydown(event: KeyboardEvent): void;
    /**
     * open selection when user click on element
     */
    click(): void;
    /**
     * focus on element when user press tab to focus on element
     * and don't open selection, to open selection user need to press space
     */
    _focus(): void;
    /**
     * close selection when user press tab to blur on element
     */
    _blur(): void;
    open(): void;
    close(): void;
    submit(): void;
    keydown(event: KeyboardEvent): void;
    selectAll(): void;
    deselectAll(): void;
    toggle(): void;
    clear(): void;
    private _removeOptionsSubscription;
    private _initSelectionModel;
    private _updateSelectionModel;
    private _getOptions;
    /**
     * check selected options
     */
    private get _getSelectedOptions();
    private _createObservableOptions;
    private _openOverlay;
    private _getPositionStrategy;
    private _closeOverlay;
    /** Invoked when an option is clicked. */
    private _onSelect;
    static ɵfac: i0.ɵɵFactoryDeclaration<KcSelectComponent<any, any, any>, [null, null, null, null, { attribute: "tabindex"; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KcSelectComponent<any, any, any>, "kc-select", ["kcSelect"], { "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "dialog": { "alias": "dialog"; "required": false; }; "origin": { "alias": "origin"; "required": false; }; "cdkOverlayConfig": { "alias": "cdkOverlayConfig"; "required": false; }; "positions": { "alias": "positions"; "required": false; }; }, { "closed": "closed"; "submitted": "submitted"; }, ["_valueDirective", "optionComponents", "_groupDirectives", "_optionsDirectives"], ["*"], false, never>;
}

declare class KcSelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<KcSelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<KcSelectModule, [typeof KcSelectComponent, typeof KcValueComponent, typeof KcGroupComponent, typeof KcOptionsComponent, typeof KcOptionComponent, typeof KcValueDirective, typeof KcGroupDirective, typeof KcOptionsDirective, typeof KcOptionDirective, typeof KcCloseDirective, typeof KcSelectAllDirective, typeof KcDeselectAllDirective, typeof KcToggleDirective, typeof KcClearDirective, typeof KcSubmitDirective, typeof KcOriginDirective], [typeof i17.CommonModule, typeof i18.OverlayModule], [typeof KcSelectComponent, typeof KcValueComponent, typeof KcGroupComponent, typeof KcOptionsComponent, typeof KcOptionComponent, typeof KcValueDirective, typeof KcGroupDirective, typeof KcOptionsDirective, typeof KcOptionDirective, typeof KcCloseDirective, typeof KcSelectAllDirective, typeof KcDeselectAllDirective, typeof KcToggleDirective, typeof KcClearDirective, typeof KcSubmitDirective, typeof KcOriginDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<KcSelectModule>;
}

declare const KC_SELECT: InjectionToken<KcSelect<unknown>>;

declare const KC_SELECTION: InjectionToken<MapEmitSelect<unknown, unknown, false>>;

declare const KC_VALUE: InjectionToken<unknown>;

export { KC_SELECT, KC_SELECTION, KC_VALUE, KcClearDirective, KcCloseDirective, KcDeselectAllDirective, KcGroupComponent, KcGroupDirective, KcOptionComponent, KcOptionDirective, KcOptionsComponent, KcOptionsDirective, KcOriginDirective, KcSelectAllDirective, KcSelectComponent, KcSelectModule, KcSubmitDirective, KcToggleDirective, KcValueComponent, KcValueDirective, MapEmitSelect, filterNestedOptions, getSelectedOptions, getValues, isOptionChunks, provideKcOption };
export type { KcGroup, KcOption, KcOptionGroupValue, KcOptionSelection, KcOptionValue, KcSelect, OptionGroup };