import * as _angular_core from '@angular/core';
import { TemplateRef, InjectionToken } from '@angular/core';
import { MotionOptions } from '@primeuix/motion';
import { BaseComponent } from 'primeng/basecomponent';
import * as i1 from 'primeng/bind';
import { Bind } from 'primeng/bind';
import { StepPassThrough, StepContentTemplateContext, StepPanelPassThrough, StepPanelContentTemplateContext, StepItemPassThrough, StepListPassThrough, StepPanelsPassThrough, StepperSeparatorPassThrough, StepperPassThrough } from 'primeng/types/stepper';
import { BaseStyle } from 'primeng/base';
import * as i8 from 'primeng/api';

declare class StepStyle extends BaseStyle {
    name: string;
    classes: {
        root: ({ instance }: {
            instance: any;
        }) => (string | {
            'p-step-active': any;
            'p-disabled': any;
        })[];
        header: string;
        number: string;
        title: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepStyle>;
}
interface StepStyle extends BaseStyle {
}

/**
 * Step is a helper component for Stepper component.
 * @group Components
 */
declare class Step extends BaseComponent<StepPassThrough> {
    $pcStep: Step | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    pcStepper: Stepper;
    onAfterViewChecked(): void;
    /**
     * Active value of stepper.
     * @defaultValue undefined
     * @group Props
     */
    value: _angular_core.ModelSignal<number | undefined>;
    /**
     * Whether the step is disabled.
     * @defaultValue false
     * @group Props
     */
    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    active: _angular_core.Signal<boolean>;
    isStepDisabled: _angular_core.Signal<boolean>;
    stepTabindex: _angular_core.Signal<-1 | undefined>;
    ariaCurrent: _angular_core.Signal<"step" | undefined>;
    id: _angular_core.Signal<string>;
    ariaControls: _angular_core.Signal<string>;
    isSeparatorVisible: _angular_core.Signal<boolean>;
    /**
     * Content template.
     * @type {TemplateRef<StepContentTemplateContext>}
     * @group Templates
     */
    content: _angular_core.Signal<TemplateRef<StepContentTemplateContext> | undefined>;
    _componentStyle: StepStyle;
    private onStepClickCallback;
    contentContext: _angular_core.Signal<StepContentTemplateContext>;
    onStepClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Step, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Step, "p-step", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["content"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

declare class StepPanelStyle extends BaseStyle {
    name: string;
    classes: {
        root: ({ instance }: {
            instance: any;
        }) => (string | {
            'p-steppanel-active': any;
        })[];
        contentWrapper: string;
        content: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepPanelStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepPanelStyle>;
}
interface StepPanelStyle extends BaseStyle {
}

/**
 * StepPanel is a helper component for Stepper component.
 * @group Components
 */
declare class StepPanel extends BaseComponent<StepPanelPassThrough> {
    $pcStepPanel: StepPanel | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    pcStepper: Stepper;
    onAfterViewChecked(): void;
    /**
     * Active value of stepper.
     * @defaultValue undefined
     * @group Props
     */
    value: _angular_core.ModelSignal<number | undefined>;
    active: _angular_core.Signal<boolean>;
    ariaControls: _angular_core.Signal<string>;
    id: _angular_core.Signal<string>;
    isVertical: _angular_core.Signal<boolean>;
    isSeparatorVisible: _angular_core.Signal<boolean | undefined>;
    computedMotionOptions: _angular_core.Signal<MotionOptions>;
    /**
     * Content template.
     * @param {StepPanelContentTemplateContext} context - Context of the template
     * @see {@link StepPanelContentTemplateContext}
     * @group Templates
     */
    contentTemplate: _angular_core.Signal<TemplateRef<StepPanelContentTemplateContext> | undefined>;
    _componentStyle: StepPanelStyle;
    updateValueCallback: any;
    contentContext: _angular_core.Signal<StepPanelContentTemplateContext>;
    updateValue(value: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepPanel, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepPanel, "p-step-panel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["contentTemplate"], never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

declare class StepItemStyle extends BaseStyle {
    name: string;
    classes: {
        root: ({ instance }: {
            instance: any;
        }) => (string | {
            'p-stepitem-active': any;
        })[];
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepItemStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepItemStyle>;
}
interface StepItemStyle extends BaseStyle {
}

/**
 * StepItem is a helper component for Stepper component used in vertical orientation.
 * @group Components
 */
declare class StepItem extends BaseComponent<StepItemPassThrough> {
    $pcStepItem: StepItem | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    _componentStyle: StepItemStyle;
    onAfterViewChecked(): void;
    pcStepper: Stepper;
    /**
     * Value of step.
     * @defaultValue undefined
     * @group Props
     */
    value: _angular_core.ModelSignal<number | undefined>;
    isActive: _angular_core.Signal<boolean>;
    step: _angular_core.Signal<Step | undefined>;
    stepPanel: _angular_core.Signal<StepPanel | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepItem, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepItem, "p-step-item", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["step", "stepPanel"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

declare class StepListStyle extends BaseStyle {
    name: string;
    classes: {
        root: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepListStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepListStyle>;
}
interface StepListStyle extends BaseStyle {
}

declare class StepList extends BaseComponent<StepListPassThrough> {
    $pcStepList: StepList | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    steps: _angular_core.Signal<readonly Step[]>;
    _componentStyle: StepListStyle;
    onAfterViewChecked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepList, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepList, "p-step-list", never, {}, {}, ["steps"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

/**
 *
 * Stepper is a component that streamlines a wizard-like workflow, organizing content into coherent steps and visually guiding users through a numbered progression in a multi-step process.
 *
 * [Live Demo](https://www.primeng.org/stepper/)
 *
 * @module stepperstyle
 *
 */
declare enum StepperClasses {
    /**
     * Class name of the root element
     */
    root = "p-stepper",
    /**
     * Class name of the separator element
     */
    separator = "p-stepper-separator"
}
declare class StepperStyle extends BaseStyle {
    name: string;
    style: string;
    classes: {
        root: ({ instance }: {
            instance: any;
        }) => (string | {
            'p-readonly': any;
        })[];
        separator: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepperStyle>;
}
interface StepperStyle extends BaseStyle {
}

declare class StepPanelsStyle extends BaseStyle {
    name: string;
    classes: {
        root: string;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepPanelsStyle, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StepPanelsStyle>;
}
interface StepPanelsStyle extends BaseStyle {
}

declare class StepPanels extends BaseComponent<StepPanelsPassThrough> {
    $pcStepPanels: StepPanels | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    _componentStyle: StepPanelsStyle;
    onAfterViewChecked(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepPanels, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepPanels, "p-step-panels", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

/**
 * StepperSeparator is a helper component for Stepper component used in vertical orientation.
 * @group Components
 */
declare class StepperSeparator extends BaseComponent<StepperSeparatorPassThrough> {
    $pcStepperSeparator: StepperSeparator | undefined;
    bindDirectiveInstance: Bind;
    componentName: string;
    onAfterViewChecked(): void;
    _componentStyle: StepperStyle;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperSeparator, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepperSeparator, "p-stepper-separator", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}

/**
 * Stepper is a component that streamlines a wizard-like workflow, organizing content into coherent steps and visually guiding users through a numbered progression in a multistep process.
 * @group Components
 */
declare class Stepper extends BaseComponent<StepperPassThrough> {
    componentName: string;
    $pcStepper: Stepper | undefined;
    bindDirectiveInstance: Bind;
    _componentStyle: StepperStyle;
    onAfterViewChecked(): void;
    /**
     * A model that can hold a numeric value or be undefined.
     * @defaultValue undefined
     * @group Props
     */
    value: _angular_core.ModelSignal<number | undefined>;
    /**
     * A boolean variable that captures user input.
     * @defaultValue false
     * @group Props
     */
    linear: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * The motion options.
     * @group Props
     */
    motionOptions: _angular_core.InputSignal<MotionOptions | undefined>;
    computedMotionOptions: _angular_core.Signal<MotionOptions>;
    id: _angular_core.WritableSignal<string>;
    stepItems: _angular_core.Signal<readonly StepItem[]>;
    steps: _angular_core.Signal<readonly Step[]>;
    stepList: _angular_core.Signal<StepList | undefined>;
    updateValue(value: number): void;
    isStepActive(value: number): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Stepper, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Stepper, "p-stepper", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "motionOptions": { "alias": "motionOptions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["stepItems", "steps", "stepList"], ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
}
declare class StepperModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<StepperModule, never, [typeof Stepper, typeof StepList, typeof StepPanels, typeof StepPanel, typeof StepItem, typeof Step, typeof StepperSeparator, typeof i8.SharedModule, typeof i1.BindModule], [typeof Stepper, typeof StepList, typeof StepPanels, typeof StepPanel, typeof StepItem, typeof Step, typeof StepperSeparator, typeof i8.SharedModule, typeof i1.BindModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<StepperModule>;
}

declare const STEPPER_INSTANCE: InjectionToken<any>;
declare const STEPLIST_INSTANCE: InjectionToken<any>;
declare const STEPITEM_INSTANCE: InjectionToken<any>;
declare const STEP_INSTANCE: InjectionToken<any>;
declare const STEPPANEL_INSTANCE: InjectionToken<any>;
declare const STEPPANELS_INSTANCE: InjectionToken<any>;
declare const STEPPERSEPARATOR_INSTANCE: InjectionToken<any>;

export { STEPITEM_INSTANCE, STEPLIST_INSTANCE, STEPPANELS_INSTANCE, STEPPANEL_INSTANCE, STEPPERSEPARATOR_INSTANCE, STEPPER_INSTANCE, STEP_INSTANCE, Step, StepItem, StepList, StepPanel, StepPanels, Stepper, StepperClasses, StepperModule, StepperSeparator, StepperStyle };