primenglab 22.0.0-beta.1

package/types/primenglab-splitter.d.ts

@@ -0,0 +1,334 @@
+import { SplitterPanelPassThrough, SplitterPassThrough, SplitterStateStorage, SplitterLayout, SplitterResizeEndEvent, SplitterResizeStartEvent, SplitterResizeEvent, SplitterCollapseEvent } from 'primenglab/types/splitter';
+export * from 'primenglab/types/splitter';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import { VoidListener, Nullable } from 'primenglab/ts-helpers';
+import { CSSProperties } from 'primenglab/types/shared';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primenglab/base';
+import * as i3 from 'primenglab/api';
+
+/**
+ *
+ * Splitter is utilized to separate and resize panels.
+ *
+ * [Live Demo](https://www.primeng.org/splitter/)
+ *
+ * @module splitterstyle
+ *
+ */
+declare enum SplitterClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-splitter",
+    /**
+     * Class name of the panel element
+     */
+    panel = "p-splitter-panel",
+    /**
+     * Class name of the gutter element
+     */
+    gutter = "p-splitter-gutter",
+    /**
+     * Class name of the handle element
+     */
+    gutterHandle = "p-splitter-gutter-handle"
+}
+declare class SplitterStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => string[];
+        panel: string;
+        gutter: string;
+        gutterHandle: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SplitterStyle>;
+}
+interface SplitterStyle extends BaseStyle {
+}
+
+/**
+ * SplitterPanel is a helper component for Splitter, used to define a single resizable panel
+ * together with its size constraints (min/max size, collapsible behavior).
+ * @group Components
+ */
+declare class SplitterPanel extends BaseComponent<SplitterPanelPassThrough> {
+    componentName: string;
+    bindDirectiveInstance: Bind;
+    /**
+     * Initial size of the panel relative to 100%.
+     * @group Props
+     */
+    size: _angular_core.InputSignalWithTransform<number | undefined, number | undefined>;
+    /**
+     * Minimum size of the panel relative to 100%.
+     * @defaultValue 0
+     * @group Props
+     */
+    minSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Maximum size of the panel relative to 100%.
+     * @defaultValue 100
+     * @group Props
+     */
+    maxSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * When enabled, the panel can collapse below its `minSize` down to `collapsedSize`.
+     * @defaultValue false
+     * @group Props
+     */
+    collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Size of the panel when collapsed, relative to 100%.
+     * @defaultValue 0
+     * @group Props
+     */
+    collapsedSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * @ignore
+     * Content of the panel, stamped by the parent Splitter into the panel wrapper.
+     */
+    contentTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /**
+     * @ignore
+     * `class`/`style` set directly on the `<p-splitterpanel>` element are forwarded by the parent
+     * Splitter onto the panel it renders, so authors can style the panel inline as expected.
+     */
+    get hostClass(): string;
+    get hostStyle(): string | null;
+    _componentStyle: SplitterStyle;
+    onAfterViewChecked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SplitterPanel, "p-splitterpanel, p-splitter-panel", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsedSize": { "alias": "collapsedSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Runtime configuration of a panel, resolved either from a SplitterPanel component or from the
+ * array-based inputs (minSizes/panelSizes) for backward compatibility.
+ */
+interface SplitterPanelMeta {
+    minSize: number;
+    maxSize: number;
+    collapsible: boolean;
+    collapsedSize: number;
+    size: number | undefined;
+}
+interface SplitterPanelInfo extends SplitterPanelMeta {
+    index: number;
+    collapsed: boolean;
+}
+/**
+ * Splitter is utilized to separate and resize panels.
+ * @group Components
+ */
+declare class Splitter extends BaseComponent<SplitterPassThrough> {
+    componentName: string;
+    bindDirectiveInstance: Bind;
+    /**
+     * Style class of the component.
+     * @group Props
+     */
+    styleClass: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Style class of the panel.
+     * @group Props
+     */
+    panelStyleClass: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Inline style of the panel.
+     * @group Props
+     */
+    panelStyle: _angular_core.InputSignal<CSSProperties>;
+    /**
+     * Defines where a stateful splitter keeps its state, valid values are 'session' for sessionStorage and 'local' for localStorage.
+     * @group Props
+     */
+    stateStorage: _angular_core.InputSignal<SplitterStateStorage>;
+    /**
+     * Storage identifier of a stateful Splitter.
+     * @group Props
+     */
+    stateKey: _angular_core.InputSignal<string | null>;
+    /**
+     * Orientation of the panels. Valid values are 'horizontal' and 'vertical'.
+     * @group Props
+     */
+    layout: _angular_core.InputSignal<SplitterLayout>;
+    /**
+     * Size of the divider in pixels.
+     * @group Props
+     */
+    gutterSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Step factor to increment/decrement the size of the panels while pressing the arrow keys.
+     * @group Props
+     */
+    step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Minimum size of the elements relative to 100%. Used when panels are defined via `#panel` templates;
+     * when SplitterPanel components are used, the per-panel `minSize` input takes precedence.
+     * @group Props
+     */
+    minSizes: _angular_core.InputSignal<number[]>;
+    /**
+     * Size of the elements relative to 100%. Used when panels are defined via `#panel` templates;
+     * when SplitterPanel components are used, the per-panel `size` input takes precedence.
+     * @group Props
+     */
+    panelSizes: _angular_core.InputSignal<number[]>;
+    /**
+     * When present, it disables the component and prevents resizing.
+     * @defaultValue false
+     * @group Props
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Callback to invoke when resize ends.
+     * @param {SplitterResizeEndEvent} event - Custom panel resize end event
+     * @group Emits
+     */
+    onResizeEnd: _angular_core.OutputEmitterRef<SplitterResizeEndEvent>;
+    /**
+     * Callback to invoke when resize starts.
+     * @param {SplitterResizeStartEvent} event - Custom panel resize start event
+     * @group Emits
+     */
+    onResizeStart: _angular_core.OutputEmitterRef<SplitterResizeStartEvent>;
+    /**
+     * Callback to invoke continuously while a gutter is being dragged.
+     * @param {SplitterResizeEvent} event - Custom panel resize event
+     * @group Emits
+     */
+    onResize: _angular_core.OutputEmitterRef<SplitterResizeEvent>;
+    /**
+     * Callback to invoke when a collapsible panel collapses or expands.
+     * @param {SplitterCollapseEvent} event - Custom collapse event
+     * @group Emits
+     */
+    onCollapse: _angular_core.OutputEmitterRef<SplitterCollapseEvent>;
+    /**
+     * Panels declared via SplitterPanel components.
+     * @ignore
+     */
+    panelComponents: _angular_core.Signal<readonly SplitterPanel[]>;
+    /**
+     * Panels declared via `<ng-template #panel>` (backward compatible API).
+     * @ignore
+     */
+    panelChildren: _angular_core.Signal<readonly TemplateRef<void>[]>;
+    /**
+     * Resolved panel content templates, sourced from SplitterPanel components when present,
+     * otherwise from `#panel` templates.
+     */
+    panels: _angular_core.Signal<TemplateRef<any>[]>;
+    /**
+     * Resolved per-panel configuration (min/max/collapsible/collapsedSize/size).
+     */
+    panelMetas: _angular_core.Signal<SplitterPanelMeta[]>;
+    /**
+     * Value-based signature of the panel configuration. Lets the (re)initialization effect ignore
+     * array-literal input bindings that change identity but not value on every parent change detection.
+     */
+    panelSignature: _angular_core.Signal<string>;
+    /**
+     * Class for each panel wrapper: the base panel class plus the splitter-level `panelStyleClass`
+     * and the `class` set directly on the matching SplitterPanel.
+     */
+    panelClass: _angular_core.Signal<(string | undefined)[]>;
+    /**
+     * Inline style for each panel wrapper: the `style` set directly on the matching SplitterPanel,
+     * falling back to the splitter-level `panelStyle`.
+     */
+    panelInlineStyle: _angular_core.Signal<(string | CSSProperties)[]>;
+    dragging: boolean;
+    isResizing: _angular_core.WritableSignal<boolean>;
+    resizingIndex: _angular_core.WritableSignal<number | null>;
+    collapsed: _angular_core.WritableSignal<boolean[]>;
+    /**
+     * Flex values applied to each panel wrapper, e.g. `35 1 0px`. Bound declaratively so panel sizing
+     * never depends on imperative DOM timing.
+     */
+    panelFlex: _angular_core.WritableSignal<string[]>;
+    dataResizing: _angular_core.Signal<"" | null>;
+    pointerMoveListener: VoidListener;
+    pointerUpListener: VoidListener;
+    size: Nullable<number>;
+    gutterElement: Nullable<ElementRef | HTMLElement>;
+    startPos: Nullable<number>;
+    _panelSizes: number[];
+    panelRegistry: SplitterPanelInfo[];
+    initialSizes: number[];
+    initialCollapsed: boolean[];
+    reportedCollapsed: boolean[];
+    initialTotal: number;
+    prevPanelIndex: Nullable<number>;
+    timer: ReturnType<typeof setTimeout> | undefined;
+    prevSize: string | undefined;
+    _componentStyle: SplitterStyle;
+    rootClass: _angular_core.Signal<string | undefined>;
+    constructor();
+    onAfterViewChecked(): void;
+    buildPanelRegistry(): void;
+    initializePanels(): void;
+    updateFlex(): void;
+    syncCollapsedState(): void;
+    getPanelMinSize(index: number): number;
+    getPanelMaxSize(index: number): number;
+    resizeStart(event: PointerEvent | KeyboardEvent, index: number, isKeyDown?: boolean): void;
+    onResizeMove(event: PointerEvent | KeyboardEvent, step?: number, isKeyDown?: boolean): void;
+    distribute(newSizes: number[], growIdx: number, requested: number, isKeyDown: boolean | undefined, direction: 'forward' | 'backward'): void;
+    validatePanelSize(rawSize: number, info: SplitterPanelInfo | undefined, min: number, isKeyDown: boolean | undefined): {
+        size: number;
+        collapsed: boolean;
+    };
+    range(start: number, end: number, step: number): number[];
+    resizeEnd(event: PointerEvent | KeyboardEvent): void;
+    onGutterPointerDown(event: PointerEvent, index: number): void;
+    repeat(event: KeyboardEvent, index: number, step: number): void;
+    setTimer(event: KeyboardEvent, index: number, step: number): void;
+    clearTimer(): void;
+    onGutterKeyUp(event: KeyboardEvent): void;
+    onGutterKeyDown(event: KeyboardEvent, index: number): void;
+    bindPointerListeners(): void;
+    unbindPointerListeners(): void;
+    clear(): void;
+    isStateful(): boolean;
+    getStorage(): Storage | undefined;
+    saveState(): void;
+    restoreState(): boolean;
+    /**
+     * Resets the panel sizes using the stored state (for a stateful Splitter), the configured
+     * sizes, or the default equal distribution.
+     */
+    resetState(): void;
+    gutterInlineStyle(): {
+        width: string;
+        'touch-action': string;
+        'user-select': string;
+    } | {
+        height: string;
+        'touch-action': string;
+        'user-select': string;
+    };
+    horizontal(): boolean;
+    round(value: number | undefined): number;
+    onDestroy(): void;
+    dataP: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Splitter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Splitter, "p-splitter", never, { "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "panelStyleClass": { "alias": "panelStyleClass"; "required": false; "isSignal": true; }; "panelStyle": { "alias": "panelStyle"; "required": false; "isSignal": true; }; "stateStorage": { "alias": "stateStorage"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "gutterSize": { "alias": "gutterSize"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "onResizeEnd": "onResizeEnd"; "onResizeStart": "onResizeStart"; "onResize": "onResize"; "onCollapse": "onCollapse"; }, ["panelComponents", "panelChildren"], never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class SplitterModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SplitterModule, never, [typeof Splitter, typeof SplitterPanel, typeof i3.SharedModule, typeof i1.BindModule], [typeof Splitter, typeof SplitterPanel, typeof i3.SharedModule, typeof i1.BindModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SplitterModule>;
+}
+
+export { Splitter, SplitterClasses, SplitterModule, SplitterPanel, SplitterStyle };

package/types/primenglab-stepper.d.ts

@@ -0,0 +1,311 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken } from '@angular/core';
+import { MotionOptions } from '@primeuix/motion';
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import { StepPassThrough, StepContentTemplateContext, StepPanelPassThrough, StepPanelContentTemplateContext, StepItemPassThrough, StepListPassThrough, StepPanelsPassThrough, StepperSeparatorPassThrough, StepperPassThrough } from 'primenglab/types/stepper';
+import { BaseStyle } from 'primenglab/base';
+import * as i8 from 'primenglab/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 };