@slotted/angular 0.0.0-stage → 0.1.0-beta.0

package/types/slotted-angular-wizard.d.ts

@@ -0,0 +1,441 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, WizardMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, AfterContentInit, TemplateRef } from '@angular/core';
+import { FormErrorInput } from '@slotted/core/form';
+import { ChangeRequest, ChangeReason } from '@slotted/core/state';
+import { WizardValue, WizardSnapshot, StepValues, WizardPersistence, WizardStepEntry } from '@slotted/core/wizard';
+export { StepValues, WizardPersistence, WizardSnapshot, WizardValue } from '@slotted/core/wizard';
+
+/** Where the list of steps stands: beside the step, above it, or nowhere. */
+type WizardProgress = 'start' | 'top' | 'none';
+/** What scrolls: the page around the wizard, or the wizard's own step. */
+type WizardScroll = 'ancestor' | 'self';
+/** When a draft is written without the reader asking. */
+type WizardAutosave = 'none' | 'step';
+type WizardLevel = 2 | 3 | 4;
+type WizardStepReason = Extract<ChangeReason, 'pointer' | 'keyboard' | 'submit' | 'programmatic'>;
+type WizardValueReason = Extract<ChangeReason, 'submit' | 'clear' | 'programmatic'>;
+type WizardProgressOpenReason = Extract<ChangeReason, 'pointer' | 'keyboard' | 'select' | 'escape' | 'programmatic'>;
+type WizardDraftReason = Extract<ChangeReason, 'pointer' | 'submit' | 'programmatic'>;
+interface WizardStepRequest extends ChangeRequest<string> {
+    readonly reason: WizardStepReason;
+}
+interface WizardValueRequest extends ChangeRequest<WizardValue> {
+    readonly reason: WizardValueReason;
+}
+interface WizardProgressOpenRequest extends ChangeRequest<boolean> {
+    readonly reason: WizardProgressOpenReason;
+}
+interface WizardDefaults {
+    progress: WizardProgress;
+    linear: boolean;
+    level: WizardLevel;
+    scroll: WizardScroll;
+    /** How long an asynchronous restore may take before its skeleton is drawn. */
+    delay: number;
+    /** How long a drawn skeleton stays, so it does not flash. */
+    minDuration: number;
+}
+/**
+ * What a submission may answer instead of succeeding. `step` sends the reader
+ * back to the step whose answers the server refused, and `errors` are
+ * published to that step's form, keyed by control name.
+ */
+interface WizardFailure {
+    message?: string | undefined;
+    step?: string | undefined;
+    errors?: FormErrorInput | undefined;
+}
+interface WizardSubmitRequest {
+    reason: 'submit';
+    source: unknown;
+    /** Every accepted answer, including steps that are not present any more. */
+    value: WizardValue;
+}
+type WizardSubmit = (values: WizardValue, request: WizardSubmitRequest) => void | WizardFailure | Promise<void | WizardFailure>;
+interface WizardCancelRequest {
+    /** Whether anything typed or accepted has not been submitted. */
+    dirty: boolean;
+    source: unknown;
+}
+interface WizardDraftRequest {
+    snapshot: WizardSnapshot;
+    reason: WizardDraftReason;
+    source: unknown;
+}
+interface WizardValidateContext {
+    value: WizardValue;
+    signal: AbortSignal;
+}
+type WizardValidate = (values: StepValues, context: WizardValidateContext) => FormErrorInput | void | Promise<FormErrorInput | void>;
+/**
+ * `linear` is on: the wave's scope says direct navigation depends on the
+ * steps already completed. `delay` and `minDuration` are the loading-states
+ * pair, so a restore that answers in eighty milliseconds draws nothing.
+ */
+declare const WIZARD_FALLBACK: WizardDefaults;
+declare const WIZARD_DEFAULTS: InjectionToken<WizardDefaults>;
+/**
+ * An application decides once how its wizards lay out. A wizard that states
+ * any of it itself still wins. Its words come from the language in force
+ * (`provideSlotted`).
+ */
+declare function provideWizardDefaults(defaults: Partial<WizardDefaults>): Provider;
+declare function injectWizardDefaults(): WizardDefaults;
+
+/** What one step's template is given. */
+interface WizardStepContext {
+    /** The answers to show: typed and not yet accepted, else accepted, else none. */
+    $implicit: StepValues;
+    values: StepValues;
+    name: string;
+    complete: boolean;
+    optional: boolean;
+    /**
+     * What a failed submission sent back for this step, keyed by control name,
+     * for the form's `[defaultErrors]`. The form family reads it once, and the
+     * wizard renders the step again when it changes.
+     */
+    errors: FormErrorInput | undefined;
+}
+/**
+ * One step: its name, its label and its content, which is rendered only while
+ * it is the current step. A branch is `@if` around the template; the wizard
+ * reacts to the list changing under the reader by the rules of the design
+ * (§5.6).
+ */
+declare class SlWizardStep {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Runs after the platform's and Reactive Forms' own validation pass. */
+    readonly validate: _angular_core.InputSignal<WizardValidate | undefined>;
+    /** The answers to accept instead of the form's values. */
+    readonly values: _angular_core.InputSignal<Readonly<Record<string, unknown>> | undefined>;
+    readonly template: TemplateRef<WizardStepContext>;
+    static ngTemplateContextGuard(_directive: SlWizardStep, context: unknown): context is WizardStepContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardStep, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardStep, "ng-template[slWizardStep]", ["slWizardStep"], { "name": { "alias": "slWizardStep"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "validate": { "alias": "validate"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** What stands in place of the step and the actions after an accepted submission. */
+declare class SlWizardComplete {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardComplete, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardComplete, "ng-template[slWizardComplete]", never, {}, {}, never, never, true, never>;
+}
+/** A row of actions of the consumer's own, in place of the default one. */
+declare class SlWizardActions {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardActions, "ng-template[slWizardActions]", never, {}, {}, never, never, true, never>;
+}
+/** The group of actions that leave the flow, at the start of the row. */
+declare class SlWizardActionsStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardActionsStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardActionsStart, "[slWizardActionsStart]", never, {}, {}, never, never, true, never>;
+}
+/** The group of actions that move the flow, at the end of the row. */
+declare class SlWizardActionsEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardActionsEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardActionsEnd, "[slWizardActionsEnd]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The step's form. It is the consumer's `form[slForm]`, because
+ * `formControlName` resolves its `ControlContainer` through the injector of
+ * the template it is written in, and a form the wizard rendered would not be
+ * that one. With a `FormGroup` on it, the group's raw value is the step's
+ * answers and its pending status holds the step; without one, `FormData`.
+ */
+declare class SlWizardForm {
+    protected readonly wizard: any;
+    private readonly form;
+    private readonly container;
+    readonly element: HTMLFormElement;
+    constructor();
+    /** What is typed now, whatever has been accepted. */
+    typed(): StepValues;
+    dirty(): boolean;
+    submit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardForm, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardForm, "form[slWizardForm]", ["slWizardForm"], {}, {}, never, never, true, never>;
+}
+/**
+ * A flow of steps that accumulates answers.
+ *
+ * **The steps are the templates the consumer writes**, and a branch is `@if`
+ * around one. The wizard reacts to the list changing under the reader by the
+ * eight rules of the design (§5.6): the current step is never moved because a
+ * step appeared before it, a current step that left the list gives way to the
+ * next one still present, and an absent step keeps its answers without
+ * submitting them.
+ *
+ * **Each step's form is the consumer's `form[slForm][slWizardForm]`**, so a
+ * `FormGroup` lives in the consumer's component, keeps what was typed across
+ * steps, and validates through Reactive Forms before the step's own
+ * `validate`. The next button stands outside the form and submits it through
+ * the platform's `form` attribute.
+ *
+ * **It holds accepted answers, not typed ones.** A step is complete exactly
+ * when its name is in `value`.
+ */
+declare class SlWizard implements AfterContentInit {
+    /** The current step's name. Two-way; a router binds it. */
+    readonly step: _angular_core.ModelSignal<string | undefined>;
+    /** The accepted answers, by step name. Two-way. */
+    readonly value: _angular_core.ModelSignal<Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined>;
+    /** Whether the compact list of steps is open. Two-way. */
+    readonly progressOpen: _angular_core.ModelSignal<boolean>;
+    /** The step an unbound wizard starts on, read once and clamped to one in reach. */
+    readonly defaultStep: _angular_core.InputSignal<string | undefined>;
+    readonly defaultValue: _angular_core.InputSignal<Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined>;
+    /** Whether an unbound compact list starts open, read once. */
+    readonly defaultProgressOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly progress: _angular_core.InputSignal<WizardProgress | undefined>;
+    readonly scroll: _angular_core.InputSignal<WizardScroll | undefined>;
+    readonly linear: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly level: _angular_core.InputSignal<WizardLevel | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * name of the list of steps (`progress`), the position, the actions, the
+     * draft status and the failures.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<WizardMessages> | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** An error of the consumer's own, shown above the step; it wins over a failed submission. */
+    readonly error: _angular_core.InputSignal<string | undefined>;
+    /** Called with the answers of the steps present, once the last step is accepted. */
+    readonly submitWizard: _angular_core.InputSignal<WizardSubmit | undefined>;
+    readonly persistence: _angular_core.InputSignal<WizardPersistence | undefined>;
+    /** The flow's version; a draft of another version is not restored. */
+    readonly version: _angular_core.InputSignal<string | number | undefined>;
+    /** Defaults to `step` when `persistence` is given, `none` otherwise. */
+    readonly autosave: _angular_core.InputSignal<WizardAutosave | undefined>;
+    readonly guardUnsaved: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Shows the cancel action. An Angular output cannot say whether anything
+     * listens to it, which is how the React binding decides; here it is stated.
+     */
+    readonly cancellable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Shows the save-draft action without `persistence`, for a `(draftSave)` of the consumer's own. */
+    readonly draftable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly minDuration: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** One output per transition, carrying its reason and `cancel()`. */
+    readonly stepChangeRequest: _angular_core.OutputEmitterRef<WizardStepRequest>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<WizardValueRequest>;
+    readonly progressOpenChangeRequest: _angular_core.OutputEmitterRef<WizardProgressOpenRequest>;
+    /** Asked by the cancel action; the family closes nothing itself. */
+    readonly cancelRequest: _angular_core.OutputEmitterRef<WizardCancelRequest>;
+    /** A draft was written, before `persistence` keeps it. */
+    readonly draftSave: _angular_core.OutputEmitterRef<WizardDraftRequest>;
+    /** The submission was accepted. */
+    readonly completed: _angular_core.OutputEmitterRef<Readonly<Record<string, Readonly<Record<string, unknown>>>>>;
+    readonly steps: _angular_core.Signal<readonly SlWizardStep[]>;
+    protected readonly completeTemplate: _angular_core.Signal<SlWizardComplete | undefined>;
+    protected readonly actionsTemplate: _angular_core.Signal<SlWizardActions | undefined>;
+    private readonly defaults;
+    private readonly injector;
+    private readonly titleRef;
+    private readonly alertRef;
+    private readonly completeRef;
+    private readonly toggleRef;
+    private readonly id;
+    readonly formId: string;
+    readonly titleId: string;
+    readonly listId: string;
+    /** The family's words in the language in force, with this wizard's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<WizardMessages>;
+    /** The locale in force: what the hour a draft was saved is written in. */
+    readonly locale: _angular_core.Signal<string>;
+    /**
+     * The list of steps is a stepper named by this family's `progress`: the
+     * written word is handed over as a message function, so the stepper never
+     * reads it as message grammar again.
+     */
+    protected readonly stepperMessages: _angular_core.Signal<{
+        label: () => string;
+    }>;
+    readonly resolvedProgress: _angular_core.Signal<WizardProgress>;
+    readonly resolvedScroll: _angular_core.Signal<WizardScroll>;
+    readonly resolvedLinear: _angular_core.Signal<boolean>;
+    readonly resolvedLevel: _angular_core.Signal<WizardLevel>;
+    private readonly resolvedAutosave;
+    readonly entries: _angular_core.Signal<WizardStepEntry[]>;
+    private readonly accepted;
+    protected readonly drafts: _angular_core.WritableSignal<Readonly<Record<string, Readonly<Record<string, unknown>>>>>;
+    protected readonly invalid: _angular_core.WritableSignal<ReadonlySet<string>>;
+    readonly pending: _angular_core.WritableSignal<string | undefined>;
+    readonly phase: _angular_core.WritableSignal<"complete" | "editing" | "submitting">;
+    protected readonly failure: _angular_core.WritableSignal<WizardFailure | undefined>;
+    readonly draftState: _angular_core.WritableSignal<"saved" | "saving" | "idle" | "failed">;
+    readonly savedAt: _angular_core.WritableSignal<Date | undefined>;
+    protected readonly restoring: _angular_core.WritableSignal<boolean>;
+    protected readonly skeleton: _angular_core.WritableSignal<boolean>;
+    private readonly returnTo;
+    private readonly epoch;
+    private readonly stepErrors;
+    private readonly form;
+    /** The list before its last change, for a current step that left it. */
+    private previousEntries;
+    /** The step the family itself last wrote, so a router's write can be told apart. */
+    private ownWrite;
+    private validation;
+    private jumpTarget;
+    private focusNext;
+    private initialised;
+    private usable;
+    /**
+     * The step shown. A requested step that is absent gives way to the next one
+     * still present in the old order (decision 2 shows that one at once); the
+     * current step is never moved because a step appeared before it (decision 1).
+     */
+    readonly current: _angular_core.Signal<string | undefined>;
+    /**
+     * After an accepted submission the flow has no current step: the stepper is
+     * given the index past the last, so every header reads complete. Left on the
+     * last step, that header kept its number, because a current step outranks a
+     * complete one.
+     */
+    protected readonly finished: _angular_core.Signal<boolean>;
+    protected readonly currentIndex: _angular_core.Signal<number>;
+    readonly currentStep: _angular_core.Signal<SlWizardStep | undefined>;
+    protected readonly optionalStep: _angular_core.Signal<boolean>;
+    readonly position: _angular_core.Signal<{
+        count: number;
+        index: number;
+    }>;
+    protected readonly positionText: _angular_core.Signal<string>;
+    readonly isFirst: _angular_core.Signal<boolean>;
+    readonly returning: _angular_core.Signal<boolean>;
+    readonly isFinal: _angular_core.Signal<boolean>;
+    protected readonly nextLabel: _angular_core.Signal<string>;
+    readonly busy: _angular_core.Signal<boolean>;
+    readonly hasForm: _angular_core.Signal<boolean>;
+    protected readonly canCancel: _angular_core.Signal<boolean>;
+    protected readonly canSaveDraft: _angular_core.Signal<boolean>;
+    protected readonly errorShown: _angular_core.Signal<boolean>;
+    protected readonly renderKey: _angular_core.Signal<string>;
+    protected readonly stepContext: _angular_core.Signal<WizardStepContext>;
+    constructor();
+    ngAfterContentInit(): void;
+    private requestStep;
+    private requestValue;
+    private requestOpen;
+    private wrap;
+    registerForm(form: SlWizardForm): void;
+    unregisterForm(form: SlWizardForm): void;
+    isComplete(name: string): boolean;
+    isReachable(name: string): boolean;
+    /**
+     * The step's form passed the platform's and Reactive Forms' validation. The
+     * step's `validate` runs next; a promise holds the next button in its
+     * loading state and is aborted when the reader leaves (decision 4).
+     */
+    commit(typed: StepValues, source: unknown): FormErrorInput | void | Promise<FormErrorInput | void>;
+    private accept;
+    private route;
+    private submitFlow;
+    private fail;
+    /** The errors a failed submission sent back for this step, for its form. */
+    errorsFor(name: string): FormErrorInput | undefined;
+    private markInvalid;
+    private leave;
+    /** What was typed on this step and not accepted, kept for when it returns. */
+    private stash;
+    private write;
+    private restore;
+    /**
+     * The step a draft was saved on, resolved after the consumer's template has
+     * run with the restored value: the step may be one that value opens, and
+     * before that render it does not exist.
+     */
+    private resolveRestored;
+    private dirty;
+    /** Submits the current step, as the next button does. */
+    next(source?: unknown): void;
+    /** One step back, keeping what was typed. */
+    previous(source?: unknown): void;
+    /** Goes to a step: back freely, forward through a submission of this one. */
+    goTo(name: string, reason?: WizardStepReason, source?: unknown): void;
+    /** Goes to a step and comes back here once it is accepted. */
+    edit(name: string, source?: unknown): void;
+    /** Accepts an optional step with no answers. */
+    skip(source?: unknown): void;
+    cancel(source?: unknown): void;
+    saveDraft(reason?: WizardDraftReason, source?: unknown): void;
+    clearDraft(): void;
+    /** Back to the first step, with no answers, no draft and no error. */
+    reset(): void;
+    focus(): void;
+    protected onHeader(request: ChangeRequest<number>): void;
+    protected toggleProgress(event: MouseEvent): void;
+    protected onProgressKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlWizard, "[slWizard]", ["slWizard"], { "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "progressOpen": { "alias": "progressOpen"; "required": false; "isSignal": true; }; "defaultStep": { "alias": "defaultStep"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "defaultProgressOpen": { "alias": "defaultProgressOpen"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "submitWizard": { "alias": "submitWizard"; "required": false; "isSignal": true; }; "persistence": { "alias": "persistence"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "autosave": { "alias": "autosave"; "required": false; "isSignal": true; }; "guardUnsaved": { "alias": "guardUnsaved"; "required": false; "isSignal": true; }; "cancellable": { "alias": "cancellable"; "required": false; "isSignal": true; }; "draftable": { "alias": "draftable"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "minDuration": { "alias": "minDuration"; "required": false; "isSignal": true; }; }, { "step": "stepChange"; "value": "valueChange"; "progressOpen": "progressOpenChange"; "stepChangeRequest": "stepChangeRequest"; "valueChangeRequest": "valueChangeRequest"; "progressOpenChangeRequest": "progressOpenChangeRequest"; "cancelRequest": "cancelRequest"; "draftSave": "draftSave"; "completed": "completed"; }, ["steps", "completeTemplate", "actionsTemplate"], never, true, never>;
+}
+/**
+ * The next button. On a plain `button` a consumer wrote it submits the step's
+ * form; beside `slButton` in the default row it is `type="submit"` associated
+ * to the form by the platform's `form` attribute. The part is a binding, so it
+ * wins over `slButton`'s static `data-part="root"` and follows the switch to
+ * `submit` on the final step.
+ */
+declare class SlWizardNext {
+    protected readonly wizard: SlWizard;
+    private readonly button;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardNext, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardNext, "button[slWizardNext]", never, {}, {}, never, never, true, never>;
+}
+declare class SlWizardPrevious {
+    private readonly wizard;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardPrevious, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardPrevious, "button[slWizardPrevious]", never, {}, {}, never, never, true, never>;
+}
+declare class SlWizardCancel {
+    private readonly wizard;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardCancel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardCancel, "button[slWizardCancel]", never, {}, {}, never, never, true, never>;
+}
+declare class SlWizardSaveDraft {
+    private readonly wizard;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardSaveDraft, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardSaveDraft, "button[slWizardSaveDraft]", never, {}, {}, never, never, true, never>;
+}
+declare class SlWizardSkip {
+    private readonly wizard;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardSkip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlWizardSkip, "button[slWizardSkip]", never, {}, {}, never, never, true, never>;
+}
+/** The polite status that says when the draft was saved. */
+declare class SlWizardDraftStatus {
+    private readonly wizard;
+    protected readonly text: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardDraftStatus, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlWizardDraftStatus, "[slWizardDraftStatus]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The control a review step puts beside each answer: it goes to the named
+ * step and sets the return point. Its name is the label and the step's label,
+ * "Change shipping address".
+ */
+declare class SlWizardEdit {
+    protected readonly wizard: SlWizard;
+    readonly step: _angular_core.InputSignal<string>;
+    protected readonly target: _angular_core.Signal<SlWizardStep | undefined>;
+    protected readonly unavailable: _angular_core.Signal<boolean>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlWizardEdit, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlWizardEdit, "button[slWizardEdit]", never, { "step": { "alias": "slWizardEdit"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SlWizard, SlWizardActions, SlWizardActionsEnd, SlWizardActionsStart, SlWizardCancel, SlWizardComplete, SlWizardDraftStatus, SlWizardEdit, SlWizardForm, SlWizardNext, SlWizardPrevious, SlWizardSaveDraft, SlWizardSkip, SlWizardStep, WIZARD_DEFAULTS, WIZARD_FALLBACK, injectWizardDefaults, provideWizardDefaults };
+export type { WizardAutosave, WizardCancelRequest, WizardDefaults, WizardDraftReason, WizardDraftRequest, WizardFailure, WizardLevel, WizardProgress, WizardProgressOpenReason, WizardProgressOpenRequest, WizardScroll, WizardStepContext, WizardStepReason, WizardStepRequest, WizardSubmit, WizardSubmitRequest, WizardValidate, WizardValidateContext, WizardValueReason, WizardValueRequest };
+//# sourceMappingURL=slotted-angular-wizard.d.ts.map

package/types/slotted-angular-wizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-wizard.d.ts","sources":["../../wizard/src/wizard-defaults.ts","../../wizard/src/wizard.ts"],"mappings":"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","names":[]}

package/types/slotted-angular.d.ts

@@ -0,0 +1,3 @@
+
+export { };
+//# sourceMappingURL=slotted-angular.d.ts.map

package/types/slotted-angular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular.d.ts","sources":[],"mappings":"","names":[]}