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

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

@@ -0,0 +1,440 @@
+import * as _slotted_core_tour from '@slotted/core/tour';
+import { TourTarget, TourOutcome, TourMissing, SpotMove, ResolvedStep } from '@slotted/core/tour';
+export { TourMissing, TourOutcome, TourTarget } from '@slotted/core/tour';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TourMessages, FamilyTranslator } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, Provider, Signal } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import * as _slotted_angular_tour from '@slotted/angular/tour';
+
+type TourSize = 'sm' | 'md' | 'lg';
+type TourSide = 'top' | 'bottom' | 'inline-start' | 'inline-end' | 'left' | 'right';
+type TourAlign = 'start' | 'center' | 'end';
+/** `auto` follows the viewport's size class; the other two decide it. */
+type TourLayout = 'auto' | 'compact' | 'regular';
+/** Somewhere to put the focus when the tour closes: an element, or a selector read in the document. */
+type TourFocusTarget = Element | string;
+/** Why the tour opened or closed. */
+type TourOpenReason = Extract<ChangeRequest<boolean>['reason'], 'pointer' | 'keyboard' | 'dismiss' | 'escape' | 'outsidePress' | 'back' | 'programmatic'>;
+/** Why the current step moved. */
+type TourStepReason = Extract<ChangeRequest<string>['reason'], 'pointer' | 'keyboard' | 'programmatic'>;
+/**
+ * The request emitted before the tour opens or closes. A close carries the
+ * outcome, as `slDialog` carries its `result`.
+ */
+interface TourOpenRequest extends ChangeRequest<boolean> {
+    readonly reason: TourOpenReason;
+    readonly outcome?: TourOutcome | undefined;
+}
+interface TourStepRequest extends ChangeRequest<string | null> {
+    readonly reason: TourStepReason;
+}
+/** The words a step may say in place of the tour's: "Start tour", "Got it". */
+type TourStepMessages = PartialMessages<Pick<TourMessages, 'next' | 'prev' | 'skip' | 'done'>>;
+interface TourStepActions {
+    prev?: boolean | undefined;
+    next?: boolean | undefined;
+    skip?: boolean | undefined;
+    close?: boolean | undefined;
+}
+interface TourStep {
+    /** Unique in the tour; the value of `step`. */
+    id: string;
+    /** An element, a selector, a ref-like `{ current }` or a function. Absent for a centred step. */
+    target?: TourTarget;
+    title: string;
+    description?: string | undefined;
+    /**
+     * The step's body. A template renders lazily, only while its step is shown;
+     * `<ng-template slTourStep="id">` in the tour's content does the same
+     * without naming the template here.
+     */
+    content?: TemplateRef<unknown> | string | undefined;
+    /** An image or a video above the header, as a template, or an image URL. */
+    media?: TemplateRef<unknown> | string | undefined;
+    side?: TourSide | undefined;
+    align?: TourAlign | undefined;
+    when?: (() => boolean) | undefined;
+    prepare?: ((signal: AbortSignal) => void | Promise<void>) | undefined;
+    interactive?: boolean | undefined;
+    advanceOn?: string | undefined;
+    spotlight?: boolean | undefined;
+    /** Laid over the tour's words for this step: "Start tour", "Got it". */
+    messages?: TourStepMessages | undefined;
+    actions?: TourStepActions | undefined;
+    /** Read aloud when the step arrives while focus is elsewhere. Defaults to the title. */
+    announcement?: string | undefined;
+}
+interface TourDefaults {
+    align: TourAlign;
+    alignOffset: number;
+    arrow: boolean;
+    arrowPadding: number;
+    autoFocus: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    collisionPadding: number;
+    keyboardNavigation: boolean;
+    layout: TourLayout;
+    missing: TourMissing;
+    modal: boolean;
+    scrollIntoView: boolean;
+    side: TourSide;
+    sideOffset: number;
+    size: TourSize;
+    spotlight: boolean;
+    targetTimeout: number;
+}
+/**
+ * `closeOnOutsidePress` is off: a press on the scrim is the easiest press on
+ * the page to make by accident, and it would throw away where the reader was.
+ * `targetTimeout` is zero: a wait shows nothing new, so a consumer whose
+ * target renders late says how late.
+ */
+declare const TOUR_FALLBACK: TourDefaults;
+declare const TOUR_DEFAULTS: InjectionToken<TourDefaults>;
+/**
+ * An application decides once how its tours behave. A tour that states any of
+ * it itself still wins, and so does a step. Its words come from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideTourDefaults(defaults: Partial<TourDefaults>): Provider;
+/** What a tour renders as here, before it states anything of its own. */
+declare function injectTourDefaults(): TourDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * two applications rendering in one server process must not share a sequence.
+ */
+declare class SlTourIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * What a part reads from the tour around it. A token rather than the class,
+ * so the parts and `sl-tour` — whose own template renders the parts — do not
+ * import each other.
+ */
+interface TourContext {
+    readonly current: Signal<TourStep | null>;
+    readonly position: Signal<number>;
+    readonly total: Signal<number>;
+    readonly first: Signal<boolean>;
+    readonly last: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly modal: Signal<boolean>;
+    /** The family's words in the language in force, with the tour's and the step's `messages` laid over them. */
+    readonly t: FamilyTranslator<TourMessages>;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    readonly hasDescription: Signal<boolean>;
+    readonly showPrev: Signal<boolean>;
+    readonly showNext: Signal<boolean>;
+    readonly showSkip: Signal<boolean>;
+    readonly showClose: Signal<boolean>;
+    /** The body the current step renders: its own template, one written for it in the tour, or text. */
+    readonly bodyTemplate: Signal<TemplateRef<unknown> | null>;
+    readonly mediaTemplate: Signal<TemplateRef<unknown> | null>;
+    next(source?: Event): void;
+    prev(source?: Event): void;
+    close(outcome: TourOutcome, source?: Event, dismiss?: boolean): void;
+    onKeyDown(event: KeyboardEvent): void;
+}
+declare const SL_TOUR: InjectionToken<TourContext>;
+
+/**
+ * `<ng-template slTourStep="share">`: the body of the step with that id,
+ * rendered only while the step is shown. `slTourStepSlot="media"` writes the
+ * picture above the header instead.
+ */
+declare class SlTourStep {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly slot: _angular_core.InputSignal<"body" | "media">;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourStep, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourStep, "ng-template[slTourStep]", never, { "id": { "alias": "slTourStep"; "required": true; "isSignal": true; }; "slot": { "alias": "slTourStepSlot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * `<ng-template slTourCard>`: the consumer's own arrangement of the card,
+ * rendered inside the positioned layer in place of the whole anatomy.
+ */
+declare class SlTourCard {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourCard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourCard, "ng-template[slTourCard]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The card. `role="dialog"`, named by the title part and described by the
+ * description part when the step has one; `aria-modal` only on a modal step,
+ * the only state in which the page behind is actually inert. The arrow keys
+ * are read here. A role or an `aria-label` the consumer wrote survives.
+ */
+declare class SlTourContent {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    protected readonly role: string | null;
+    protected readonly label: string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourContent, "[slTourContent]", never, {}, {}, never, never, true, never>;
+}
+/** The step's picture, full bleed above the header; hidden when it has none. */
+declare class SlTourMedia {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    protected readonly url: _angular_core.Signal<string | null>;
+    protected readonly shown: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourMedia, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourMedia, "[slTourMedia]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTourHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourHeader, "[slTourHeader]", never, {}, {}, never, never, true, never>;
+}
+/** “2 of 5”, counting the steps available now; hidden in a tour of one step. */
+declare class SlTourProgress {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourProgress, "[slTourProgress]", never, {}, {}, never, never, true, never>;
+}
+/** Closes with the outcome `close` and the reason `dismiss`. The cross is drawn unless the consumer wrote content of their own. */
+declare class SlTourClose {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    protected readonly label: string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourClose, "button[slTourClose]", never, {}, {}, never, ["*"], true, never>;
+}
+/** The step's title and the card's accessible name. Text written inside replaces it. */
+declare class SlTourTitle {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourTitle, "[slTourTitle]", never, {}, {}, never, ["*"], true, never>;
+}
+/** The step's description, and the card's accessible description; hidden when it has none. */
+declare class SlTourDescription {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourDescription, "[slTourDescription]", never, {}, {}, never, never, true, never>;
+}
+/** The step's content — a template or text — and the only part that scrolls. */
+declare class SlTourBody {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    protected readonly text: _angular_core.Signal<string>;
+    protected readonly shown: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTourBody, "[slTourBody]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTourFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourFooter, "[slTourFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The three actions go on the consumer's own `button slButton`. `slButton`
+ * writes `data-part="root"` as a static host attribute, which erases the part
+ * the template wrote, so each of these writes its part back after the first
+ * render, as `slTransferPart` does.
+ */
+declare abstract class TourAction {
+    protected readonly tour: _slotted_angular_tour.TourContext;
+    constructor(part: string);
+}
+/** Closes with the outcome `skip`. Hidden on the last step and in a tour of one. */
+declare class SlTourSkip extends TourAction {
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourSkip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourSkip, "button[slTourSkip]", never, {}, {}, never, never, true, never>;
+}
+/** The previous available step. Hidden on the first. */
+declare class SlTourPrev extends TourAction {
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourPrev, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourPrev, "button[slTourPrev]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The next available step, or Done on the last (`data-last`), which closes
+ * with the outcome `complete`. Hidden on a step that advances on the reader's
+ * own action at the target, unless the step asks for it.
+ */
+declare class SlTourNext extends TourAction {
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTourNext, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTourNext, "button[slTourNext]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A guided walk through an interface, one step at a time.
+ *
+ * `open` and `step` are two-way; `@slotted/core/tour` owns everything between
+ * a press and a card — conditions, preparation, a target that arrives late or
+ * never. The frame is built from a template and portalled to the end of the
+ * document, as `slPopoverLayer`'s is. A modal step makes the page `inert` and
+ * keeps focus in the card; an interactive step leaves the page reachable so
+ * the reader can operate the target.
+ *
+ * With no `ng-template slTourCard` inside, it renders the whole card.
+ */
+declare class SlTour implements TourContext {
+    readonly steps: _angular_core.InputSignal<readonly TourStep[]>;
+    /** Whether the tour is showing. Two-way. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** The current step's id. Two-way; `null` is the first available step. */
+    readonly step: _angular_core.ModelSignal<string | null>;
+    readonly size: _angular_core.InputSignal<TourSize | undefined>;
+    /** `compact` or `regular` decide the phone composition; `auto` takes it below 600 pixels of viewport. */
+    readonly layout: _angular_core.InputSignal<TourLayout | undefined>;
+    readonly side: _angular_core.InputSignal<TourSide | undefined>;
+    readonly align: _angular_core.InputSignal<TourAlign | undefined>;
+    readonly missing: _angular_core.InputSignal<TourMissing | undefined>;
+    /** Words laid over the catalog of the language in force, key by key. */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TourMessages> | undefined>;
+    readonly finalFocus: _angular_core.InputSignal<TourFocusTarget | undefined>;
+    readonly arrow: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly modalInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly spotlight: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnOutsidePress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly scrollIntoView: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly keyboardNavigation: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly targetTimeout: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** One output per transition, carrying the reason, the event and — on a close — the outcome. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<TourOpenRequest>;
+    readonly stepChangeRequest: _angular_core.OutputEmitterRef<TourStepRequest>;
+    readonly card: _angular_core.Signal<SlTourCard | undefined>;
+    private readonly stepTemplates;
+    /**
+     * Where the frame's view is inserted: inside this component's own view, so
+     * the signals its template reads mark this component for check. Inserted
+     * into the host's container instead — the parent's view — the frame was
+     * never redrawn after the first time outside a test harness that checks the
+     * whole tree: the tour opened with no scrim and its card never appeared.
+     * The frame's nodes are then moved to the portal, as before.
+     */
+    private readonly outlet;
+    private readonly defaults;
+    private readonly base;
+    private readonly viewContainer;
+    private readonly injector;
+    private readonly document;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    private readonly shown;
+    /** The cutout's target and the movement that brings it there. */
+    readonly spot: _angular_core.WritableSignal<{
+        target: Element | null;
+        move: SpotMove;
+    }>;
+    readonly leaving: _angular_core.WritableSignal<boolean>;
+    /** The card of the drawn step has been placed, and may be shown. */
+    readonly ready: _angular_core.WritableSignal<boolean>;
+    private staging;
+    readonly pending: _angular_core.WritableSignal<boolean>;
+    /** The last step drawn, kept through the exit so the card leaves as it was. */
+    readonly drawn: _angular_core.WritableSignal<ResolvedStep<TourStep> | null>;
+    readonly current: _angular_core.Signal<TourStep | null>;
+    /** The tour's own words and the drawn step's, laid over the catalog in that order. */
+    private readonly override;
+    /** The family's words in the language in force, with the tour's and the step's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<TourMessages>;
+    readonly resolvedSize: _angular_core.Signal<TourSize>;
+    /** The viewport is in the compact size class: a lateral side turns vertical, the card takes the width. */
+    private readonly narrow;
+    readonly compact: _angular_core.Signal<boolean>;
+    /** The target leaves a card room on some side; when it does not, the card is centred over it. */
+    private readonly fits;
+    readonly resolvedSide: _angular_core.Signal<_slotted_core_tour.TourSideName>;
+    readonly resolvedAlign: _angular_core.Signal<TourAlign>;
+    readonly resolvedArrow: _angular_core.Signal<boolean>;
+    readonly modal: _angular_core.Signal<boolean>;
+    private readonly resolvedSpotlight;
+    private readonly hasTarget;
+    readonly anchored: _angular_core.Signal<boolean>;
+    readonly spotlightOn: _angular_core.Signal<boolean>;
+    private readonly progress;
+    readonly position: _angular_core.Signal<number>;
+    readonly total: _angular_core.Signal<number>;
+    readonly first: _angular_core.Signal<boolean>;
+    readonly last: _angular_core.Signal<boolean>;
+    readonly hasDescription: _angular_core.Signal<boolean>;
+    readonly showPrev: _angular_core.Signal<boolean>;
+    readonly showSkip: _angular_core.Signal<boolean>;
+    readonly showClose: _angular_core.Signal<boolean>;
+    readonly showNext: _angular_core.Signal<boolean>;
+    private readonly namedTemplate;
+    readonly bodyTemplate: _angular_core.Signal<_angular_core.TemplateRef<any> | null>;
+    readonly mediaTemplate: _angular_core.Signal<_angular_core.TemplateRef<any> | null>;
+    private readonly controller;
+    private readonly status;
+    private readonly presence;
+    readonly visible: _angular_core.Signal<boolean>;
+    /**
+     * `data-open` is written a frame after the frame exists, so the scrim and
+     * the card have a closed style to arrive from.
+     */
+    readonly arrived: _angular_core.WritableSignal<boolean>;
+    private readonly mounted;
+    private readonly rootNode;
+    private frameRef;
+    private portal;
+    private closing;
+    private opener;
+    private focusedStep;
+    /** Whether focus was in the card when the reader asked to move; a dialog a step opens may take it meanwhile. */
+    private leftFromCard;
+    private layerHandle;
+    private readonly layer;
+    /** The target of an interactive step, which a press on is not a press outside. */
+    private readonly interactiveTarget;
+    private reposition_;
+    constructor();
+    private requestOpen;
+    private requestStep;
+    /** Opens the tour at a step, or at the first available one. */
+    start(id?: string): void;
+    next(source?: Event): void;
+    prev(source?: Event): void;
+    goTo(id: string): void;
+    close(outcome?: TourOutcome, source?: Event, dismiss?: boolean): void;
+    /** Measures the target and the card again, after the page moved without scrolling. */
+    reposition(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onGuardFocus(): void;
+    private contentNode;
+    private build;
+    private teardown;
+    private place;
+    /**
+     * One layer in the single stack. A modal step makes everything outside it
+     * `inert` and holds a history entry for the way back; the target of an
+     * interactive step is a branch, so pressing it is not a press outside.
+     */
+    /**
+     * The layer is made again only when something that defines it changes —
+     * whether it is modal, and the two dismissals. A modal layer holds a history
+     * entry for the way back, and one made again on every step gave its entry
+     * back and took a new one on every Next: the browser's own `popstate` for
+     * the entry given back arrived as the way back, and the tour closed itself.
+     * The target of an interactive step joins the layer as a branch instead.
+     */
+    private stack;
+    /**
+     * Focus follows the reader rather than the tour: the card takes it when the
+     * tour opens, and on a step change only when it was already in the card. A
+     * reader elsewhere keeps their place and hears the new step instead.
+     */
+    private focusStep;
+    private restoreFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTour, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTour, "sl-tour", ["slTour"], { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "missing": { "alias": "missing"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "finalFocus": { "alias": "finalFocus"; "required": false; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": false; "isSignal": true; }; "modalInput": { "alias": "modal"; "required": false; "isSignal": true; }; "spotlight": { "alias": "spotlight"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePress": { "alias": "closeOnOutsidePress"; "required": false; "isSignal": true; }; "scrollIntoView": { "alias": "scrollIntoView"; "required": false; "isSignal": true; }; "keyboardNavigation": { "alias": "keyboardNavigation"; "required": false; "isSignal": true; }; "targetTimeout": { "alias": "targetTimeout"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "step": "stepChange"; "openChangeRequest": "openChangeRequest"; "stepChangeRequest": "stepChangeRequest"; }, ["card", "stepTemplates"], never, true, never>;
+}
+
+export { SL_TOUR, SlTour, SlTourBody, SlTourCard, SlTourClose, SlTourContent, SlTourDescription, SlTourFooter, SlTourHeader, SlTourIdFactory, SlTourMedia, SlTourNext, SlTourPrev, SlTourProgress, SlTourSkip, SlTourStep, SlTourTitle, TOUR_DEFAULTS, TOUR_FALLBACK, injectTourDefaults, provideTourDefaults };
+export type { TourAlign, TourContext, TourDefaults, TourFocusTarget, TourLayout, TourOpenReason, TourOpenRequest, TourSide, TourSize, TourStep, TourStepActions, TourStepMessages, TourStepReason, TourStepRequest };
+//# sourceMappingURL=slotted-angular-tour.d.ts.map

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

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