/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directionality } from 'cdk/bidi';
import { BooleanInput, NumberInput } from 'cdk/coercion';
import {
	AfterViewInit,
	ChangeDetectorRef,
	ElementRef,
	EventEmitter,
	InjectionToken,
	OnChanges,
	OnDestroy,
	QueryList,
	TemplateRef,
	AfterContentInit,
} from '@angular/core';
import { Observable, Subject } from 'rxjs';
import { CdkStepHeader } from './step-header';
import { CdkStepLabel } from './step-label';
/**
 * Position state of the content of each step in stepper that is used for transitioning
 * the content into correct position upon step selection change.
 */
import * as ɵngcc0 from '@angular/core';
export declare type StepContentPositionState = 'previous' | 'current' | 'next';
/** Possible orientation of a stepper. */
export declare type StepperOrientation = 'horizontal' | 'vertical';
/** Change event emitted on selection changes. */
export declare class StepperSelectionEvent {
	/** Index of the step now selected. */
	selectedIndex: number;
	/** Index of the step previously selected. */
	previouslySelectedIndex: number;
	/** The step instance now selected. */
	selectedStep: CdkStep;
	/** The step instance previously selected. */
	previouslySelectedStep: CdkStep;
}
/** The state of each step. */
export declare type StepState = 'number' | 'edit' | 'done' | 'error' | string;
/** Enum to represent the different states of the steps. */
export declare const STEP_STATE: {
	NUMBER: string;
	EDIT: string;
	DONE: string;
	ERROR: string;
};
/** InjectionToken that can be used to specify the global stepper options. */
export declare const STEPPER_GLOBAL_OPTIONS: InjectionToken<StepperOptions>;
/** Configurable options for stepper. */
export interface StepperOptions {
	/**
	 * Whether the stepper should display an error state or not.
	 * Default behavior is assumed to be false.
	 */
	showError?: boolean;
	/**
	 * Whether the stepper should display the default indicator type
	 * or not.
	 * Default behavior is assumed to be true.
	 */
	displayDefaultIndicatorType?: boolean;
}
export declare class CdkStep implements OnChanges {
	_stepper: CdkStepper;
	private _stepperOptions;
	_displayDefaultIndicatorType: boolean;
	/** Template for step label if it exists. */
	stepLabel: CdkStepLabel;
	/** Template for step content. */
	content: TemplateRef<any>;
	/** The top level abstract control of the step. */
	stepControl: AbstractControlLike;
	/** Whether user has attempted to move away from the step. */
	interacted: boolean;
	/** Emits when the user has attempted to move away from the step. */
	readonly interactedStream: EventEmitter<CdkStep>;
	/** Plain text label of the step. */
	label: string;
	/** Error message to display when there's an error. */
	errorMessage: string;
	/** Aria label for the tab. */
	ariaLabel: string;
	/**
	 * Reference to the element that the tab is labelled by.
	 * Will be cleared if `aria-label` is set at the same time.
	 */
	ariaLabelledby: string;
	/** State of the step. */
	state: StepState;
	/** Whether the user can return to this step once it has been marked as completed. */
	get editable(): boolean;
	set editable(value: boolean);
	private _editable;
	/** Whether the completion of step is optional. */
	get optional(): boolean;
	set optional(value: boolean);
	private _optional;
	/** Whether step is marked as completed. */
	get completed(): boolean;
	set completed(value: boolean);
	_completedOverride: boolean | null;
	private _getDefaultCompleted;
	/** Whether step has an error. */
	get hasError(): boolean;
	set hasError(value: boolean);
	private _customError;
	private _getDefaultError;
	constructor(_stepper: CdkStepper, stepperOptions?: StepperOptions);
	/** Selects this step component. */
	select(): void;
	/** Resets the step to its initial state. Note that this includes resetting form data. */
	reset(): void;
	ngOnChanges(): void;
	_markAsInteracted(): void;
	/** Determines whether the error state can be shown. */
	_showError(): boolean;
	static ngAcceptInputType_editable: BooleanInput;
	static ngAcceptInputType_hasError: BooleanInput;
	static ngAcceptInputType_optional: BooleanInput;
	static ngAcceptInputType_completed: BooleanInput;
	static ɵfac: ɵngcc0.ɵɵFactoryDef<CdkStep, [null, { optional: true }]>;
	static ɵcmp: ɵngcc0.ɵɵComponentDefWithMeta<
		CdkStep,
		'cdk-step',
		['cdkStep'],
		{
			editable: 'editable';
			optional: 'optional';
			completed: 'completed';
			hasError: 'hasError';
			stepControl: 'stepControl';
			label: 'label';
			errorMessage: 'errorMessage';
			ariaLabel: 'aria-label';
			ariaLabelledby: 'aria-labelledby';
			state: 'state';
		},
		{ interactedStream: 'interacted' },
		['stepLabel'],
		['*']
	>;
}
export declare class CdkStepper
	implements AfterContentInit, AfterViewInit, OnDestroy
{
	private _dir;
	private _changeDetectorRef;
	private _elementRef;
	/** Emits when the component is destroyed. */
	protected readonly _destroyed: Subject<void>;
	/** Used for managing keyboard focus. */
	private _keyManager;
	/** Full list of steps inside the stepper, including inside nested steppers. */
	_steps: QueryList<CdkStep>;
	/** Steps that belong to the current stepper, excluding ones from nested steppers. */
	readonly steps: QueryList<CdkStep>;
	/** The list of step headers of the steps in the stepper. */
	_stepHeader: QueryList<CdkStepHeader>;
	/** Whether the validity of previous steps should be checked or not. */
	get linear(): boolean;
	set linear(value: boolean);
	private _linear;
	/** The index of the selected step. */
	get selectedIndex(): number;
	set selectedIndex(index: number);
	private _selectedIndex;
	/** The step that is selected. */
	get selected(): CdkStep | undefined;
	set selected(step: CdkStep | undefined);
	/** Event emitted when the selected step has changed. */
	readonly selectionChange: EventEmitter<StepperSelectionEvent>;
	/** Used to track unique ID for each stepper component. */
	_groupId: number;
	/** Orientation of the stepper. */
	get orientation(): StepperOrientation;
	set orientation(value: StepperOrientation);
	/**
	 * @deprecated To be turned into a private property. Use `orientation` instead.
	 * @breaking-change 13.0.0
	 */
	protected _orientation: StepperOrientation;
	constructor(
		_dir: Directionality,
		_changeDetectorRef: ChangeDetectorRef,
		_elementRef: ElementRef<HTMLElement>,
		/**
		 * @deprecated No longer in use, to be removed.
		 * @breaking-change 13.0.0
		 */
		_document: any
	);
	ngAfterContentInit(): void;
	ngAfterViewInit(): void;
	ngOnDestroy(): void;
	/** Selects and focuses the next step in list. */
	next(): void;
	/** Selects and focuses the previous step in list. */
	previous(): void;
	/** Resets the stepper to its initial state. Note that this includes clearing form data. */
	reset(): void;
	/** Returns a unique id for each step label element. */
	_getStepLabelId(i: number): string;
	/** Returns unique id for each step content element. */
	_getStepContentId(i: number): string;
	/** Marks the component to be change detected. */
	_stateChanged(): void;
	/** Returns position state of the step with the given index. */
	_getAnimationDirection(index: number): StepContentPositionState;
	/** Returns the type of icon to be displayed. */
	_getIndicatorType(index: number, state?: StepState): StepState;
	private _getDefaultIndicatorLogic;
	private _getGuidelineLogic;
	private _isCurrentStep;
	/** Returns the index of the currently-focused step header. */
	_getFocusIndex(): number | null;
	private _updateSelectedItemIndex;
	_onKeydown(event: KeyboardEvent): void;
	private _anyControlsInvalidOrPending;
	private _layoutDirection;
	/** Checks whether the stepper contains the focused element. */
	private _containsFocus;
	/** Checks whether the passed-in index is a valid step index. */
	private _isValidIndex;
	static ngAcceptInputType_editable: BooleanInput;
	static ngAcceptInputType_optional: BooleanInput;
	static ngAcceptInputType_completed: BooleanInput;
	static ngAcceptInputType_hasError: BooleanInput;
	static ngAcceptInputType_linear: BooleanInput;
	static ngAcceptInputType_selectedIndex: NumberInput;
	static ɵfac: ɵngcc0.ɵɵFactoryDef<
		CdkStepper,
		[{ optional: true }, null, null, null]
	>;
	static ɵdir: ɵngcc0.ɵɵDirectiveDefWithMeta<
		CdkStepper,
		'[cdkStepper]',
		['cdkStepper'],
		{
			linear: 'linear';
			selectedIndex: 'selectedIndex';
			selected: 'selected';
			orientation: 'orientation';
		},
		{ selectionChange: 'selectionChange' },
		['_steps', '_stepHeader']
	>;
}
/**
 * Simplified representation of an "AbstractControl" from @angular/forms.
 * Used to avoid having to bring in @angular/forms for a single optional interface.
 * @docs-private
 */
interface AbstractControlLike {
	asyncValidator: ((control: any) => any) | null;
	dirty: boolean;
	disabled: boolean;
	enabled: boolean;
	errors: {
		[key: string]: any;
	} | null;
	invalid: boolean;
	parent: any;
	pending: boolean;
	pristine: boolean;
	root: AbstractControlLike;
	status: string;
	readonly statusChanges: Observable<any>;
	touched: boolean;
	untouched: boolean;
	updateOn: any;
	valid: boolean;
	validator: ((control: any) => any) | null;
	value: any;
	readonly valueChanges: Observable<any>;
	clearAsyncValidators(): void;
	clearValidators(): void;
	disable(opts?: any): void;
	enable(opts?: any): void;
	get(path: (string | number)[] | string): AbstractControlLike | null;
	getError(errorCode: string, path?: (string | number)[] | string): any;
	hasError(errorCode: string, path?: (string | number)[] | string): boolean;
	markAllAsTouched(): void;
	markAsDirty(opts?: any): void;
	markAsPending(opts?: any): void;
	markAsPristine(opts?: any): void;
	markAsTouched(opts?: any): void;
	markAsUntouched(opts?: any): void;
	patchValue(value: any, options?: Object): void;
	reset(value?: any, options?: Object): void;
	setAsyncValidators(
		newValidator: (control: any) => any | ((control: any) => any)[] | null
	): void;
	setErrors(
		errors: {
			[key: string]: any;
		} | null,
		opts?: any
	): void;
	setParent(parent: any): void;
	setValidators(
		newValidator: (control: any) => any | ((control: any) => any)[] | null
	): void;
	setValue(value: any, options?: Object): void;
	updateValueAndValidity(opts?: any): void;
	patchValue(value: any, options?: any): void;
	reset(formState?: any, options?: any): void;
	setValue(value: any, options?: any): void;
}
export {};

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stepper.d.ts","sources":["stepper.d.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Directionality } from '@angular/cdk/bidi';\nimport { BooleanInput, NumberInput } from '@angular/cdk/coercion';\nimport { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, OnChanges, OnDestroy, QueryList, TemplateRef, AfterContentInit } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { CdkStepHeader } from './step-header';\nimport { CdkStepLabel } from './step-label';\n/**\n * Position state of the content of each step in stepper that is used for transitioning\n * the content into correct position upon step selection change.\n */\nexport declare type StepContentPositionState = 'previous' | 'current' | 'next';\n/** Possible orientation of a stepper. */\nexport declare type StepperOrientation = 'horizontal' | 'vertical';\n/** Change event emitted on selection changes. */\nexport declare class StepperSelectionEvent {\n    /** Index of the step now selected. */\n    selectedIndex: number;\n    /** Index of the step previously selected. */\n    previouslySelectedIndex: number;\n    /** The step instance now selected. */\n    selectedStep: CdkStep;\n    /** The step instance previously selected. */\n    previouslySelectedStep: CdkStep;\n}\n/** The state of each step. */\nexport declare type StepState = 'number' | 'edit' | 'done' | 'error' | string;\n/** Enum to represent the different states of the steps. */\nexport declare const STEP_STATE: {\n    NUMBER: string;\n    EDIT: string;\n    DONE: string;\n    ERROR: string;\n};\n/** InjectionToken that can be used to specify the global stepper options. */\nexport declare const STEPPER_GLOBAL_OPTIONS: InjectionToken<StepperOptions>;\n/** Configurable options for stepper. */\nexport interface StepperOptions {\n    /**\n     * Whether the stepper should display an error state or not.\n     * Default behavior is assumed to be false.\n     */\n    showError?: boolean;\n    /**\n     * Whether the stepper should display the default indicator type\n     * or not.\n     * Default behavior is assumed to be true.\n     */\n    displayDefaultIndicatorType?: boolean;\n}\nexport declare class CdkStep implements OnChanges {\n    _stepper: CdkStepper;\n    private _stepperOptions;\n    _displayDefaultIndicatorType: boolean;\n    /** Template for step label if it exists. */\n    stepLabel: CdkStepLabel;\n    /** Template for step content. */\n    content: TemplateRef<any>;\n    /** The top level abstract control of the step. */\n    stepControl: AbstractControlLike;\n    /** Whether user has attempted to move away from the step. */\n    interacted: boolean;\n    /** Emits when the user has attempted to move away from the step. */\n    readonly interactedStream: EventEmitter<CdkStep>;\n    /** Plain text label of the step. */\n    label: string;\n    /** Error message to display when there's an error. */\n    errorMessage: string;\n    /** Aria label for the tab. */\n    ariaLabel: string;\n    /**\n     * Reference to the element that the tab is labelled by.\n     * Will be cleared if `aria-label` is set at the same time.\n     */\n    ariaLabelledby: string;\n    /** State of the step. */\n    state: StepState;\n    /** Whether the user can return to this step once it has been marked as completed. */\n    get editable(): boolean;\n    set editable(value: boolean);\n    private _editable;\n    /** Whether the completion of step is optional. */\n    get optional(): boolean;\n    set optional(value: boolean);\n    private _optional;\n    /** Whether step is marked as completed. */\n    get completed(): boolean;\n    set completed(value: boolean);\n    _completedOverride: boolean | null;\n    private _getDefaultCompleted;\n    /** Whether step has an error. */\n    get hasError(): boolean;\n    set hasError(value: boolean);\n    private _customError;\n    private _getDefaultError;\n    constructor(_stepper: CdkStepper, stepperOptions?: StepperOptions);\n    /** Selects this step component. */\n    select(): void;\n    /** Resets the step to its initial state. Note that this includes resetting form data. */\n    reset(): void;\n    ngOnChanges(): void;\n    _markAsInteracted(): void;\n    /** Determines whether the error state can be shown. */\n    _showError(): boolean;\n    static ngAcceptInputType_editable: BooleanInput;\n    static ngAcceptInputType_hasError: BooleanInput;\n    static ngAcceptInputType_optional: BooleanInput;\n    static ngAcceptInputType_completed: BooleanInput;\n}\nexport declare class CdkStepper implements AfterContentInit, AfterViewInit, OnDestroy {\n    private _dir;\n    private _changeDetectorRef;\n    private _elementRef;\n    /** Emits when the component is destroyed. */\n    protected readonly _destroyed: Subject<void>;\n    /** Used for managing keyboard focus. */\n    private _keyManager;\n    /** Full list of steps inside the stepper, including inside nested steppers. */\n    _steps: QueryList<CdkStep>;\n    /** Steps that belong to the current stepper, excluding ones from nested steppers. */\n    readonly steps: QueryList<CdkStep>;\n    /** The list of step headers of the steps in the stepper. */\n    _stepHeader: QueryList<CdkStepHeader>;\n    /** Whether the validity of previous steps should be checked or not. */\n    get linear(): boolean;\n    set linear(value: boolean);\n    private _linear;\n    /** The index of the selected step. */\n    get selectedIndex(): number;\n    set selectedIndex(index: number);\n    private _selectedIndex;\n    /** The step that is selected. */\n    get selected(): CdkStep | undefined;\n    set selected(step: CdkStep | undefined);\n    /** Event emitted when the selected step has changed. */\n    readonly selectionChange: EventEmitter<StepperSelectionEvent>;\n    /** Used to track unique ID for each stepper component. */\n    _groupId: number;\n    /** Orientation of the stepper. */\n    get orientation(): StepperOrientation;\n    set orientation(value: StepperOrientation);\n    /**\n     * @deprecated To be turned into a private property. Use `orientation` instead.\n     * @breaking-change 13.0.0\n     */\n    protected _orientation: StepperOrientation;\n    constructor(_dir: Directionality, _changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, \n    /**\n     * @deprecated No longer in use, to be removed.\n     * @breaking-change 13.0.0\n     */\n    _document: any);\n    ngAfterContentInit(): void;\n    ngAfterViewInit(): void;\n    ngOnDestroy(): void;\n    /** Selects and focuses the next step in list. */\n    next(): void;\n    /** Selects and focuses the previous step in list. */\n    previous(): void;\n    /** Resets the stepper to its initial state. Note that this includes clearing form data. */\n    reset(): void;\n    /** Returns a unique id for each step label element. */\n    _getStepLabelId(i: number): string;\n    /** Returns unique id for each step content element. */\n    _getStepContentId(i: number): string;\n    /** Marks the component to be change detected. */\n    _stateChanged(): void;\n    /** Returns position state of the step with the given index. */\n    _getAnimationDirection(index: number): StepContentPositionState;\n    /** Returns the type of icon to be displayed. */\n    _getIndicatorType(index: number, state?: StepState): StepState;\n    private _getDefaultIndicatorLogic;\n    private _getGuidelineLogic;\n    private _isCurrentStep;\n    /** Returns the index of the currently-focused step header. */\n    _getFocusIndex(): number | null;\n    private _updateSelectedItemIndex;\n    _onKeydown(event: KeyboardEvent): void;\n    private _anyControlsInvalidOrPending;\n    private _layoutDirection;\n    /** Checks whether the stepper contains the focused element. */\n    private _containsFocus;\n    /** Checks whether the passed-in index is a valid step index. */\n    private _isValidIndex;\n    static ngAcceptInputType_editable: BooleanInput;\n    static ngAcceptInputType_optional: BooleanInput;\n    static ngAcceptInputType_completed: BooleanInput;\n    static ngAcceptInputType_hasError: BooleanInput;\n    static ngAcceptInputType_linear: BooleanInput;\n    static ngAcceptInputType_selectedIndex: NumberInput;\n}\n/**\n * Simplified representation of an \"AbstractControl\" from @angular/forms.\n * Used to avoid having to bring in @angular/forms for a single optional interface.\n * @docs-private\n */\ninterface AbstractControlLike {\n    asyncValidator: ((control: any) => any) | null;\n    dirty: boolean;\n    disabled: boolean;\n    enabled: boolean;\n    errors: {\n        [key: string]: any;\n    } | null;\n    invalid: boolean;\n    parent: any;\n    pending: boolean;\n    pristine: boolean;\n    root: AbstractControlLike;\n    status: string;\n    readonly statusChanges: Observable<any>;\n    touched: boolean;\n    untouched: boolean;\n    updateOn: any;\n    valid: boolean;\n    validator: ((control: any) => any) | null;\n    value: any;\n    readonly valueChanges: Observable<any>;\n    clearAsyncValidators(): void;\n    clearValidators(): void;\n    disable(opts?: any): void;\n    enable(opts?: any): void;\n    get(path: (string | number)[] | string): AbstractControlLike | null;\n    getError(errorCode: string, path?: (string | number)[] | string): any;\n    hasError(errorCode: string, path?: (string | number)[] | string): boolean;\n    markAllAsTouched(): void;\n    markAsDirty(opts?: any): void;\n    markAsPending(opts?: any): void;\n    markAsPristine(opts?: any): void;\n    markAsTouched(opts?: any): void;\n    markAsUntouched(opts?: any): void;\n    patchValue(value: any, options?: Object): void;\n    reset(value?: any, options?: Object): void;\n    setAsyncValidators(newValidator: (control: any) => any | ((control: any) => any)[] | null): void;\n    setErrors(errors: {\n        [key: string]: any;\n    } | null, opts?: any): void;\n    setParent(parent: any): void;\n    setValidators(newValidator: (control: any) => any | ((control: any) => any)[] | null): void;\n    setValue(value: any, options?: Object): void;\n    updateValueAndValidity(opts?: any): void;\n    patchValue(value: any, options?: any): void;\n    reset(formState?: any, options?: any): void;\n    setValue(value: any, options?: any): void;\n}\nexport {};\n"]}