import * as i2 from '@angular/cdk/stepper';
import { CdkStepper, CdkStep, CdkStepHeader, CdkStepperNext, CdkStepperPrevious, CdkStepLabel } from '@angular/cdk/stepper';
import * as i0 from '@angular/core';
import { AfterContentInit, QueryList, OnChanges, OnDestroy, ChangeDetectorRef, ElementRef, DoCheck, AfterViewInit, AfterViewChecked } from '@angular/core';
import { Directionality } from '@angular/cdk/bidi';
import { FormControl, FormGroupDirective, NgForm } from '@angular/forms';
import { ErrorStateMatcher } from '@aposin/ng-aquila/utils';
import { Subject } from 'rxjs';
import { FocusMonitor } from '@angular/cdk/a11y';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i1 from '@angular/common';
import * as i3 from '@aposin/ng-aquila/icon';
import * as i4 from '@aposin/ng-aquila/progressbar';
import * as i5 from '@aposin/ng-aquila/base';

declare class NxStepComponent extends CdkStep implements ErrorStateMatcher, OnChanges, OnDestroy {
    readonly stepper: NxProgressStepperDirective;
    private readonly _errorStateMatcher;
    constructor(stepper: NxProgressStepperDirective, _errorStateMatcher: ErrorStateMatcher);
    private _stepControl;
    /** The top level abstract control of the step. */
    stepControl: any;
    private isInteracted;
    readonly _destroyed: Subject<void>;
    wasCompleted: boolean;
    /** Custom error state matcher that checks for validity of the step form. */
    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxStepComponent, [null, { skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxStepComponent, "nx-step", ["nxStep"], {}, {}, never, ["*"], true, never>;
}
/** @docs-private */
declare class NxProgressStepperDirective extends CdkStepper implements AfterContentInit {
    private readonly _cdr;
    /** Full list of steps inside the stepper, including inside nested steppers */
    _steps: QueryList<NxStepComponent>;
    /** Steps that belong to the current stepper, excluding ones from nested steppers. */
    readonly steps: QueryList<NxStepComponent>;
    _stepHeader: QueryList<CdkStepHeader>;
    /** Sets the label on the left side showing the current step label. Used for mobile viewports. */
    currentStepLabel: string;
    constructor(_cdr: ChangeDetectorRef, _dir: Directionality | null, _elementRef: ElementRef<HTMLElement>);
    ngAfterContentInit(): void;
    /** @docs-private */
    get hasPrevious(): boolean;
    /** @docs-private */
    get hasNext(): boolean;
    /** @docs-private */
    get count(): number;
    /** @docs-private */
    get currentStep(): NxStepComponent | null;
    /** @docs-private */
    get nextStep(): NxStepComponent | null;
    /** @docs-private */
    get currentLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxProgressStepperDirective, [null, { optional: true; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxProgressStepperDirective, "[nxProgressStepper]", ["nxProgressStepper"], { "currentStepLabel": { "alias": "currentStepLabel"; "required": false; }; }, {}, ["_steps"], never, true, never>;
}

declare class NxStepperNextDirective extends CdkStepperNext implements DoCheck {
    private readonly _cdr;
    /** @docs-private */
    disabled: boolean;
    constructor(_stepper: CdkStepper, _cdr: ChangeDetectorRef);
    /**
     * Implemented to prevent changed after checked error after stepper init.
     * When the stepper initializes the directive is checked first before
     * the stepper can check its content thus it doesn't know about it's children yet
     * so _stepper.hasNext returns false and disables the buttons. In the same CD cycle
     * after the stepper has checked its contents the button needs to be enabled resulting
     * in the error.
     */
    ngDoCheck(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxStepperNextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxStepperNextDirective, "button[nxStepperNext]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}
declare class NxStepperPreviousDirective extends CdkStepperPrevious {
    constructor(_stepper: CdkStepper);
    get stepper(): NxProgressStepperDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxStepperPreviousDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxStepperPreviousDirective, "button[nxStepperPrevious]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}

/** Direction of the multi stepper */
type NxMultiStepperDirection = 'vertical' | 'horizontal';

declare class NxMultiStepperGroupComponent {
    private readonly _cdr;
    /** @docs-private */
    steps: QueryList<NxStepComponent>;
    /** Sets the label of a group that is shown to the user. */
    set label(value: string);
    get label(): string;
    private _label;
    constructor(_cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiStepperGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiStepperGroupComponent, "nx-step-group", never, { "label": { "alias": "label"; "required": false; }; }, {}, ["steps"], ["*"], true, never>;
}

/** @docs-private */
declare class NxMultiStepItemComponent extends CdkStepHeader implements OnDestroy, AfterViewInit {
    private readonly _cdr;
    readonly _elementRef: ElementRef<HTMLElement>;
    private readonly _focusMonitor;
    /** The direction of the step */
    set direction(value: NxMultiStepperDirection);
    get direction(): NxMultiStepperDirection;
    private _direction;
    /** The label of the step. */
    label: CdkStepLabel | string;
    /** Sets the selected step. */
    set selected(value: BooleanInput);
    get selected(): boolean;
    private _selected;
    /** Sets the active step. */
    set active(value: BooleanInput);
    get active(): boolean;
    private _active;
    set disabled(value: BooleanInput);
    get disabled(): boolean;
    private _disabled;
    /** Sets the last step. */
    set last(value: BooleanInput);
    get last(): boolean;
    private _last;
    /** Sets the step completed. */
    set completed(value: BooleanInput);
    get completed(): boolean;
    private _completed;
    /** Sets the step was completed. */
    set wasCompleted(value: BooleanInput);
    get wasCompleted(): boolean;
    private _wasCompleted;
    set ariaControls(value: string);
    get ariaControls(): string;
    private _ariaControls;
    constructor(_cdr: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, _focusMonitor: FocusMonitor);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiStepItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiStepItemComponent, "nx-multi-step-item", never, { "direction": { "alias": "direction"; "required": false; }; "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "last": { "alias": "last"; "required": false; }; "completed": { "alias": "completed"; "required": false; }; "wasCompleted": { "alias": "wasCompleted"; "required": false; }; "ariaControls": { "alias": "ariaControls"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NxMultiStepperComponent extends NxProgressStepperDirective implements OnDestroy, AfterContentInit, AfterViewChecked {
    /**
     * We need to set the `_stepHeader` property as `ViewChildren` here as it is a `ContentChildren` query in the CDK.
     */
    _stepHeader: QueryList<NxMultiStepItemComponent>;
    /** @docs-private */
    groups: QueryList<NxMultiStepperGroupComponent>;
    /** Sets the direction of the multi stepper. */
    set direction(value: NxMultiStepperDirection);
    get direction(): NxMultiStepperDirection;
    private _direction;
    constructor(_cdr: ChangeDetectorRef, _dir: Directionality | null, _el: ElementRef<HTMLElement>);
    ngAfterViewChecked(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    _stepDisabled(index: number): boolean;
    private get _stepsInGroups();
    _getIndex(step: NxStepComponent): number;
    _isGroupActive(groupIndex: number): boolean;
    _isGroupDisabled(groupIndex: number): boolean;
    private getGroupItemIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiStepperComponent, [null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiStepperComponent, "nx-multi-stepper", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, ["groups"], ["nx-label"], true, never>;
}

declare class NxProgressStepperComponent extends NxProgressStepperDirective {
    /** Overrides the `aria-label` of the nx-progressbar. Defaults to "Progress" */
    progressbarAriaLabel: string | undefined;
    /** Sets the `aria-labelledby` of the nx-progressbar */
    progressbarAriaLabeledBy: string | undefined;
    /** Sets the current value/progress of the progress bar. */
    set progress(value: number);
    get progress(): number;
    private _progress;
    constructor(_cdr: ChangeDetectorRef, _dir: Directionality | null, _el: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxProgressStepperComponent, [null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxProgressStepperComponent, "nx-progress-stepper", never, { "progressbarAriaLabel": { "alias": "progressbarAriaLabel"; "required": false; }; "progressbarAriaLabeledBy": { "alias": "progressbarAriaLabeledBy"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; }, {}, never, ["nx-label"], true, never>;
}

declare class NxSingleStepperComponent extends NxProgressStepperDirective {
    /** Sets the label on the right showing the next step. */
    set rightLabel(v: string);
    get rightLabel(): string;
    private _rightLabel;
    /** Overrides the `aria-label` of the nx-progressbar. Defaults to "Progress" */
    progressbarAriaLabel: string | undefined;
    /** Sets the `aria-labelledby` of the nx-progressbar */
    progressbarAriaLabeledBy: string | undefined;
    /** @docs-private */
    get progress(): number;
    /** @docs-private */
    get currentLabel(): string;
    /** @docs-private */
    get nextLabel(): string | null;
    constructor(_cdr: ChangeDetectorRef, _dir: Directionality | null, _el: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxSingleStepperComponent, [null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxSingleStepperComponent, "nx-single-stepper", never, { "rightLabel": { "alias": "nextLabel"; "required": false; }; "progressbarAriaLabel": { "alias": "progressbarAriaLabel"; "required": false; }; "progressbarAriaLabeledBy": { "alias": "progressbarAriaLabeledBy"; "required": false; }; }, {}, never, ["nx-label"], true, never>;
}

declare class NxProgressStepperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxProgressStepperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NxProgressStepperModule, never, [typeof i1.CommonModule, typeof i2.CdkStepperModule, typeof i3.NxIconModule, typeof i4.NxProgressbarModule, typeof i5.NxLabelModule, typeof NxProgressStepperDirective, typeof NxMultiStepperComponent, typeof NxStepComponent, typeof NxStepperNextDirective, typeof NxStepperPreviousDirective, typeof NxProgressStepperComponent, typeof NxSingleStepperComponent, typeof NxMultiStepItemComponent, typeof NxMultiStepperGroupComponent], [typeof NxProgressStepperDirective, typeof NxSingleStepperComponent, typeof NxProgressStepperComponent, typeof NxMultiStepperComponent, typeof NxStepComponent, typeof NxStepperNextDirective, typeof NxStepperPreviousDirective, typeof NxMultiStepperGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NxProgressStepperModule>;
}

export { NxMultiStepItemComponent, NxMultiStepperComponent, NxMultiStepperGroupComponent, NxProgressStepperComponent, NxProgressStepperDirective, NxProgressStepperModule, NxSingleStepperComponent, NxStepComponent, NxStepperNextDirective, NxStepperPreviousDirective };
export type { NxMultiStepperDirection };