@globalpayments-private/gpds-pattern-web 0.0.0-stage → 0.1.0-pr.7.gdcb74cd

package/dist/types/components/uds-pattern-login-card/validation/login-validation-rules.d.ts

@@ -0,0 +1,72 @@
+import { FormFieldValidationRule, FormFieldStatusMeta } from '@globalpayments/vega/dist/types/helpers/validator/rules/form-field-validation-rule';
+import { EvaluateResult } from '@globalpayments/vega/dist/types/helpers/validator/rules/validation-rule';
+/**
+ * The pattern's own `vega-form` validation rules.
+ *
+ * ## Why rules rather than a pre-submit check
+ *
+ * `vega-form` already gates submission: its submit handler awaits `valid()` and
+ * only emits `vegaFormSubmit` when every field passes. Anything the pattern
+ * checks *outside* that gate is a second, competing validation pass — it fires
+ * at a different moment, reports through a different surface (a card-level
+ * banner rather than the field at fault), and has to be kept in step by hand.
+ *
+ * Expressing the same checks as rules puts them inside the one flow. The field
+ * that is wrong is the field that says so, the error clears as the user fixes
+ * it, and the submit gate needs no pattern-specific code at all.
+ *
+ * ## Why these two, and nothing else
+ *
+ * Everything Vega already derives from a prop — `required`, `type="email"`,
+ * `minLength` — is left to Vega, including its wording. Restating "this field
+ * is required" here would fork copy that the design system maintains for every
+ * Global Payments product. Only checks Vega cannot express from a prop alone
+ * live here: one that needs a sibling field's value, and one that needs the
+ * configured code length.
+ *
+ * ## Why they read through callbacks
+ *
+ * A rule is handed to `vega-input` as a prop and re-read when its identity
+ * changes, so rebuilding the array on each render would churn Vega's watchers
+ * every time any unrelated state moved. These are built once and resolve their
+ * inputs — the value to compare against, the message to show — when they are
+ * evaluated, so a single stable instance always sees current state.
+ */
+/** Evaluated only once the field has a value; emptiness is `required`'s job. */
+declare abstract class NonEmptyStringRule implements FormFieldValidationRule<string> {
+    canEvaluate(input: unknown, status?: FormFieldStatusMeta): boolean;
+    /**
+     * Mirrors Vega's built-in rules: say nothing until the user has engaged with
+     * the field, so a freshly rendered step is not pre-littered with errors.
+     */
+    shouldShowError(status?: FormFieldStatusMeta): boolean;
+    abstract evaluate(input: string): EvaluateResult;
+}
+/**
+ * Requires a field to equal another field's current value.
+ *
+ * Used for the "confirm new password" pairing, which no single-field rule can
+ * express: the answer depends on a sibling that may change after this field was
+ * last touched.
+ */
+export declare class MatchesFieldRule extends NonEmptyStringRule {
+    private readonly expected;
+    private readonly message;
+    constructor(expected: () => string, message: () => string);
+    evaluate(input: string): EvaluateResult;
+}
+/**
+ * Requires every character of a passcode to be present.
+ *
+ * `required` alone is not enough here. It only asks whether the value is
+ * non-empty, so a half-typed code — three boxes of six — satisfies it and
+ * reaches the provider, which then has to answer a question the pattern could
+ * have answered without a round trip.
+ */
+export declare class CompleteCodeRule extends NonEmptyStringRule {
+    private readonly length;
+    private readonly message;
+    constructor(length: () => number, message: (length: number) => string);
+    evaluate(input: string): EvaluateResult;
+}
+export {};

package/dist/types/components/uds-pattern-login-card/view-model/login-card-handlers.d.ts

@@ -0,0 +1,21 @@
+import { UdsLoginAction, UdsLoginStep } from '../../../utils/types';
+/**
+ * The behaviour a renderer may invoke, kept deliberately apart from
+ * `LoginStepViewModel`.
+ *
+ * Renderers receive data (the view model) and intents (this object). Neither
+ * knows how the intent is serviced — that is the workflow slimmer's business —
+ * which is what keeps the rendering layer free of workflow decisions.
+ */
+export interface LoginCardHandlers {
+    /** The form was submitted on the current step. */
+    onSubmit(event: Event): void;
+    /** An in-workflow link was followed. */
+    onNavigate(step: UdsLoginStep): (event: Event) => void;
+    /** An intent the pattern cannot resolve itself (the help links). */
+    onAction(action: UdsLoginAction): (event: Event) => void;
+    /** The resend-code affordance was used. */
+    onResend(event: Event): void;
+    /** A collected field changed. */
+    onValueChange(name: string, value: string | boolean): void;
+}

package/dist/types/components/uds-pattern-login-card/view-model/login-step.view-model.d.ts

@@ -0,0 +1,96 @@
+import { UdsMfaMethod } from '../../../providers/auth-provider';
+import { UdsLoginLabels, UdsLoginStep } from '../../../utils/types';
+/**
+ * The data a renderer needs to draw one step of the login workflow.
+ *
+ * ## Why this is a class with a factory, and not an inline object
+ *
+ * Deriving "what the user should see" from "what the workflow currently holds"
+ * is real logic: which affordances are available, what the heading says, which
+ * description variant applies, whether a countdown is running. Assembled inline
+ * inside `render()` that derivation is untestable and re-read on every change;
+ * named here it has one home, one test surface and one place to review.
+ *
+ * ## Why it carries no callbacks
+ *
+ * A view model is *data*. Handlers are supplied alongside it
+ * (`LoginCardHandlers`) rather than folded in, because a model that carries
+ * behaviour cannot be compared, snapshotted or reasoned about independently of
+ * the component that produced it. Keeping the two apart is what lets the
+ * renderers be checked as pure functions of their inputs.
+ *
+ * ## Pattern-library standard
+ *
+ * Every pattern component should follow this shape:
+ *
+ * - `view-model/<pattern>.view-model.ts` exporting a plain data class;
+ * - construction through a single `static from(state)` factory;
+ * - no inheritance, and no logic beyond derivation from the state passed in;
+ * - consumed by renderer slimmers, never mutated by them.
+ *
+ * Note this is a *view model*, not a DTO: it never crosses a process or
+ * serialisation boundary, only the boundary between the stateful layer
+ * (slimmers) and the rendering layer. DTO semantics — validation, wire format —
+ * belong at the provider seam, where data genuinely enters from outside.
+ */
+export declare class LoginStepViewModel {
+    /** The step being rendered. */
+    readonly step: UdsLoginStep;
+    /** Resolved copy, after merging any consumer overrides. */
+    readonly copy: UdsLoginLabels;
+    /** Heading for this step. */
+    readonly heading: string;
+    /** Supporting description, when this step has one. */
+    readonly description: string | undefined;
+    /** Error copy to surface, already mapped to approved wording. */
+    readonly errorText: string | undefined;
+    /** Whether a provider call is in flight. */
+    readonly busy: boolean;
+    /** Which affordances the provider can service. */
+    readonly can: StepCapabilities;
+    /** MFA methods offered by the provider. */
+    readonly methods: UdsMfaMethod[];
+    /** Values collected on the current step. */
+    readonly values: Readonly<Record<string, string | boolean>>;
+    /** How many characters the passcode entry expects. */
+    readonly otpLength: number;
+    /** Seconds left on the resend throttle; zero when resending is allowed. */
+    readonly resendSeconds: number;
+    private constructor();
+    static from(state: LoginViewState): LoginStepViewModel;
+    /** Steps that render no form: terminal outcomes and confirmations. */
+    get isTerminal(): boolean;
+    /** Whether a resend is currently throttled. */
+    get isResendThrottled(): boolean;
+    /** Copy for the throttle countdown, with the remaining seconds applied. */
+    get resendCountdownText(): string;
+    /** The current value of a collected field, as a string. */
+    valueOf(name: string): string;
+    /** Whether a boolean field is set. */
+    isChecked(name: string): boolean;
+}
+/** Which affordances are available, derived from the provider's capabilities. */
+export interface StepCapabilities {
+    signUp: boolean;
+    reset: boolean;
+    username: boolean;
+    resend: boolean;
+}
+/** The component state a view model is derived from. */
+export interface LoginViewState {
+    step: UdsLoginStep;
+    copy: UdsLoginLabels;
+    errorText?: string;
+    busy: boolean;
+    can: StepCapabilities;
+    methods: UdsMfaMethod[];
+    values: Record<string, string | boolean>;
+    otpLength: number;
+    resendSeconds: number;
+    /** Label of the MFA method a code was sent to, when one was chosen. */
+    otpMethodLabel?: string;
+    /** Masked destination a reset link or reminder was sent to. */
+    destination?: string;
+    /** Minutes until a locked account unlocks, when the provider said. */
+    unlockMinutes?: number;
+}

package/dist/types/components/uds-pattern-login-page/uds-pattern-login-page.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Full-page layout shell for authentication screens: branded masthead, a
+ * centred content column sized for `uds-pattern-login-card`, and an optional legal
+ * footer.
+ *
+ * It exists so consuming portals do not re-implement the same centred,
+ * responsive, brandable login layout for every product.
+ *
+ * @slot brand - Replaces the default masthead logo (e.g. a partner lockup).
+ * @slot - The authentication card, typically a `uds-pattern-login-card`.
+ * @slot footer - Legal / utility links rendered beneath the content column.
+ */
+export declare class UdsPatternLoginPage {
+    /** URL of the masthead logo. Ignored when the `brand` slot is used. */
+    logoSrc?: string;
+    /** Accessible name for the masthead logo. */
+    logoAlt: string;
+    /** Destination for the masthead logo link. When unset the logo is not a link. */
+    logoHref?: string;
+    render(): any;
+}

package/dist/types/components.d.ts

@@ -0,0 +1,327 @@
+/* eslint-disable */
+/* tslint:disable */
+/**
+ * This is an autogenerated file created by the Stencil compiler.
+ * It contains typing information for all components that exist in this project.
+ */
+import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
+import { UdsLoginConfig } from "./providers/login-config";
+import { UdsLoginActionDetail, UdsLoginErrorDetail, UdsLoginStep, UdsLoginStepChangeDetail } from "./utils/types";
+import { UdsSession } from "./providers/auth-provider";
+export { UdsLoginConfig } from "./providers/login-config";
+export { UdsLoginActionDetail, UdsLoginErrorDetail, UdsLoginStep, UdsLoginStepChangeDetail } from "./utils/types";
+export { UdsSession } from "./providers/auth-provider";
+export namespace Components {
+    /**
+     * The GP login workflow, as a single pattern.
+     * Unlike a design-system component, this pattern **owns the workflow**: step
+     * sequencing, in-flight state, failure copy, resend throttling, lockout
+     * messaging, back-navigation, focus movement and identifier persistence all
+     * live inside the card. A consuming product does not implement any of it.
+     * Two aggregate seams are all a consumer wires:
+     * - **`auth`** — a `UdsAuthProvider` adapter saying *what the identity platform
+     *   needs next*. The pattern decides what that looks like.
+     * - **`controlStrategy`** — an optional `UdsLoginControlStrategy` that intercepts
+     *   every checkpoint in the workflow, for the cases where the course of the flow
+     *   itself needs to change.
+     * ```ts
+     * card.auth = createAuthProvider({
+     *   signIn:    ({ identifier, password }) => oktaSdk.authn(identifier, password),
+     *   verifyOtp: ({ code })                 => oktaSdk.verifyFactor(code),
+     * });
+     * ```
+     * Which optional methods the adapter implements is also the configuration:
+     * implement `signUp` and the sign-up route appears; omit `requestPasswordReset`
+     * and no recovery link is rendered.
+     * This class deliberately holds only props, events, state and the render shell.
+     * Behaviour lives in slimmers (`./slimmers`), markup in renderer slimmers
+     * (`./slimmers/renderers`) and derivation in `./view-model` — see
+     * `src/slimmer/README.md`.
+     */
+    interface UdsPatternLoginCard {
+        /**
+          * Everything that cannot be expressed as an attribute: the `auth` adapter, the `control` strategy and any `labels` overrides.  The split is mechanical rather than a matter of taste — see `UdsLoginConfig`. Scalars below are attributes because they can be; objects and functions are gathered here because they cannot be.  Also accepts a JSON string, so the `labels` member alone can be set from plain HTML markup.
+          * @default {}
+         */
+        "config": UdsLoginConfig | string;
+        /**
+          * Pre-populates the identifier field, overriding any remembered value.
+          * @default ''
+         */
+        "identifier": string;
+        /**
+          * The step the workflow starts on.
+          * @default 'identifier'
+         */
+        "initialStep": UdsLoginStep;
+        /**
+          * Default number of digit inputs, when the provider does not specify one.
+          * @default 6
+         */
+        "otpLength": number;
+        /**
+          * Where the "Remember my email" value is persisted. Set to an empty string to disable persistence entirely.
+          * @default 'uds-pattern-login.identifier'
+         */
+        "rememberStorageKey": string;
+        /**
+          * Returns the workflow to its first step and clears all collected input. Useful after a sign-out, or to recover from a terminal step.
+         */
+        "reset": () => Promise<void>;
+        /**
+          * Renders the "Need help signing in?" footer.
+          * @default true
+         */
+        "showHelpFooter": boolean;
+    }
+    /**
+     * Full-page layout shell for authentication screens: branded masthead, a
+     * centred content column sized for `uds-pattern-login-card`, and an optional legal
+     * footer.
+     * It exists so consuming portals do not re-implement the same centred,
+     * responsive, brandable login layout for every product.
+     */
+    interface UdsPatternLoginPage {
+        /**
+          * Accessible name for the masthead logo.
+          * @default ''
+         */
+        "logoAlt": string;
+        /**
+          * Destination for the masthead logo link. When unset the logo is not a link.
+         */
+        "logoHref"?: string;
+        /**
+          * URL of the masthead logo. Ignored when the `brand` slot is used.
+         */
+        "logoSrc"?: string;
+    }
+}
+export interface UdsPatternLoginCardCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLUdsPatternLoginCardElement;
+}
+declare global {
+    interface HTMLUdsPatternLoginCardElementEventMap {
+        "udsLoginSuccess": { session?: UdsSession };
+        "udsLoginStepChange": UdsLoginStepChangeDetail;
+        "udsLoginError": UdsLoginErrorDetail;
+        "udsLoginAction": UdsLoginActionDetail;
+    }
+    /**
+     * The GP login workflow, as a single pattern.
+     * Unlike a design-system component, this pattern **owns the workflow**: step
+     * sequencing, in-flight state, failure copy, resend throttling, lockout
+     * messaging, back-navigation, focus movement and identifier persistence all
+     * live inside the card. A consuming product does not implement any of it.
+     * Two aggregate seams are all a consumer wires:
+     * - **`auth`** — a `UdsAuthProvider` adapter saying *what the identity platform
+     *   needs next*. The pattern decides what that looks like.
+     * - **`controlStrategy`** — an optional `UdsLoginControlStrategy` that intercepts
+     *   every checkpoint in the workflow, for the cases where the course of the flow
+     *   itself needs to change.
+     * ```ts
+     * card.auth = createAuthProvider({
+     *   signIn:    ({ identifier, password }) => oktaSdk.authn(identifier, password),
+     *   verifyOtp: ({ code })                 => oktaSdk.verifyFactor(code),
+     * });
+     * ```
+     * Which optional methods the adapter implements is also the configuration:
+     * implement `signUp` and the sign-up route appears; omit `requestPasswordReset`
+     * and no recovery link is rendered.
+     * This class deliberately holds only props, events, state and the render shell.
+     * Behaviour lives in slimmers (`./slimmers`), markup in renderer slimmers
+     * (`./slimmers/renderers`) and derivation in `./view-model` — see
+     * `src/slimmer/README.md`.
+     */
+    interface HTMLUdsPatternLoginCardElement extends Components.UdsPatternLoginCard, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLUdsPatternLoginCardElementEventMap>(type: K, listener: (this: HTMLUdsPatternLoginCardElement, ev: UdsPatternLoginCardCustomEvent<HTMLUdsPatternLoginCardElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLUdsPatternLoginCardElementEventMap>(type: K, listener: (this: HTMLUdsPatternLoginCardElement, ev: UdsPatternLoginCardCustomEvent<HTMLUdsPatternLoginCardElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLUdsPatternLoginCardElement: {
+        prototype: HTMLUdsPatternLoginCardElement;
+        new (): HTMLUdsPatternLoginCardElement;
+    };
+    /**
+     * Full-page layout shell for authentication screens: branded masthead, a
+     * centred content column sized for `uds-pattern-login-card`, and an optional legal
+     * footer.
+     * It exists so consuming portals do not re-implement the same centred,
+     * responsive, brandable login layout for every product.
+     */
+    interface HTMLUdsPatternLoginPageElement extends Components.UdsPatternLoginPage, HTMLStencilElement {
+    }
+    var HTMLUdsPatternLoginPageElement: {
+        prototype: HTMLUdsPatternLoginPageElement;
+        new (): HTMLUdsPatternLoginPageElement;
+    };
+    interface HTMLElementTagNameMap {
+        "uds-pattern-login-card": HTMLUdsPatternLoginCardElement;
+        "uds-pattern-login-page": HTMLUdsPatternLoginPageElement;
+    }
+}
+declare namespace LocalJSX {
+    /**
+     * The GP login workflow, as a single pattern.
+     * Unlike a design-system component, this pattern **owns the workflow**: step
+     * sequencing, in-flight state, failure copy, resend throttling, lockout
+     * messaging, back-navigation, focus movement and identifier persistence all
+     * live inside the card. A consuming product does not implement any of it.
+     * Two aggregate seams are all a consumer wires:
+     * - **`auth`** — a `UdsAuthProvider` adapter saying *what the identity platform
+     *   needs next*. The pattern decides what that looks like.
+     * - **`controlStrategy`** — an optional `UdsLoginControlStrategy` that intercepts
+     *   every checkpoint in the workflow, for the cases where the course of the flow
+     *   itself needs to change.
+     * ```ts
+     * card.auth = createAuthProvider({
+     *   signIn:    ({ identifier, password }) => oktaSdk.authn(identifier, password),
+     *   verifyOtp: ({ code })                 => oktaSdk.verifyFactor(code),
+     * });
+     * ```
+     * Which optional methods the adapter implements is also the configuration:
+     * implement `signUp` and the sign-up route appears; omit `requestPasswordReset`
+     * and no recovery link is rendered.
+     * This class deliberately holds only props, events, state and the render shell.
+     * Behaviour lives in slimmers (`./slimmers`), markup in renderer slimmers
+     * (`./slimmers/renderers`) and derivation in `./view-model` — see
+     * `src/slimmer/README.md`.
+     */
+    interface UdsPatternLoginCard {
+        /**
+          * Everything that cannot be expressed as an attribute: the `auth` adapter, the `control` strategy and any `labels` overrides.  The split is mechanical rather than a matter of taste — see `UdsLoginConfig`. Scalars below are attributes because they can be; objects and functions are gathered here because they cannot be.  Also accepts a JSON string, so the `labels` member alone can be set from plain HTML markup.
+          * @default {}
+         */
+        "config"?: UdsLoginConfig | string;
+        /**
+          * Pre-populates the identifier field, overriding any remembered value.
+          * @default ''
+         */
+        "identifier"?: string;
+        /**
+          * The step the workflow starts on.
+          * @default 'identifier'
+         */
+        "initialStep"?: UdsLoginStep;
+        /**
+          * Emitted for the two intents the pattern cannot resolve — the help links. In-workflow navigation is handled internally and is not reported here.
+         */
+        "onUdsLoginAction"?: (event: UdsPatternLoginCardCustomEvent<UdsLoginActionDetail>) => void;
+        /**
+          * Emitted when the provider reports a failure, after the card has displayed it.
+         */
+        "onUdsLoginError"?: (event: UdsPatternLoginCardCustomEvent<UdsLoginErrorDetail>) => void;
+        /**
+          * Emitted whenever the workflow moves to a different step.
+         */
+        "onUdsLoginStepChange"?: (event: UdsPatternLoginCardCustomEvent<UdsLoginStepChangeDetail>) => void;
+        /**
+          * Emitted once the provider reports successful authentication.
+         */
+        "onUdsLoginSuccess"?: (event: UdsPatternLoginCardCustomEvent<{ session?: UdsSession }>) => void;
+        /**
+          * Default number of digit inputs, when the provider does not specify one.
+          * @default 6
+         */
+        "otpLength"?: number;
+        /**
+          * Where the "Remember my email" value is persisted. Set to an empty string to disable persistence entirely.
+          * @default 'uds-pattern-login.identifier'
+         */
+        "rememberStorageKey"?: string;
+        /**
+          * Renders the "Need help signing in?" footer.
+          * @default true
+         */
+        "showHelpFooter"?: boolean;
+    }
+    /**
+     * Full-page layout shell for authentication screens: branded masthead, a
+     * centred content column sized for `uds-pattern-login-card`, and an optional legal
+     * footer.
+     * It exists so consuming portals do not re-implement the same centred,
+     * responsive, brandable login layout for every product.
+     */
+    interface UdsPatternLoginPage {
+        /**
+          * Accessible name for the masthead logo.
+          * @default ''
+         */
+        "logoAlt"?: string;
+        /**
+          * Destination for the masthead logo link. When unset the logo is not a link.
+         */
+        "logoHref"?: string;
+        /**
+          * URL of the masthead logo. Ignored when the `brand` slot is used.
+         */
+        "logoSrc"?: string;
+    }
+
+    interface UdsPatternLoginCardAttributes {
+        "config": UdsLoginConfig | string;
+        "initialStep": UdsLoginStep;
+        "identifier": string;
+        "otpLength": number;
+        "rememberStorageKey": string;
+        "showHelpFooter": boolean;
+    }
+    interface UdsPatternLoginPageAttributes {
+        "logoSrc": string;
+        "logoAlt": string;
+        "logoHref": string;
+    }
+
+    interface IntrinsicElements {
+        "uds-pattern-login-card": Omit<UdsPatternLoginCard, keyof UdsPatternLoginCardAttributes> & { [K in keyof UdsPatternLoginCard & keyof UdsPatternLoginCardAttributes]?: UdsPatternLoginCard[K] } & { [K in keyof UdsPatternLoginCard & keyof UdsPatternLoginCardAttributes as `attr:${K}`]?: UdsPatternLoginCardAttributes[K] } & { [K in keyof UdsPatternLoginCard & keyof UdsPatternLoginCardAttributes as `prop:${K}`]?: UdsPatternLoginCard[K] };
+        "uds-pattern-login-page": Omit<UdsPatternLoginPage, keyof UdsPatternLoginPageAttributes> & { [K in keyof UdsPatternLoginPage & keyof UdsPatternLoginPageAttributes]?: UdsPatternLoginPage[K] } & { [K in keyof UdsPatternLoginPage & keyof UdsPatternLoginPageAttributes as `attr:${K}`]?: UdsPatternLoginPageAttributes[K] } & { [K in keyof UdsPatternLoginPage & keyof UdsPatternLoginPageAttributes as `prop:${K}`]?: UdsPatternLoginPage[K] };
+    }
+}
+export { LocalJSX as JSX };
+declare module "@stencil/core" {
+    export namespace JSX {
+        interface IntrinsicElements {
+            /**
+             * The GP login workflow, as a single pattern.
+             * Unlike a design-system component, this pattern **owns the workflow**: step
+             * sequencing, in-flight state, failure copy, resend throttling, lockout
+             * messaging, back-navigation, focus movement and identifier persistence all
+             * live inside the card. A consuming product does not implement any of it.
+             * Two aggregate seams are all a consumer wires:
+             * - **`auth`** — a `UdsAuthProvider` adapter saying *what the identity platform
+             *   needs next*. The pattern decides what that looks like.
+             * - **`controlStrategy`** — an optional `UdsLoginControlStrategy` that intercepts
+             *   every checkpoint in the workflow, for the cases where the course of the flow
+             *   itself needs to change.
+             * ```ts
+             * card.auth = createAuthProvider({
+             *   signIn:    ({ identifier, password }) => oktaSdk.authn(identifier, password),
+             *   verifyOtp: ({ code })                 => oktaSdk.verifyFactor(code),
+             * });
+             * ```
+             * Which optional methods the adapter implements is also the configuration:
+             * implement `signUp` and the sign-up route appears; omit `requestPasswordReset`
+             * and no recovery link is rendered.
+             * This class deliberately holds only props, events, state and the render shell.
+             * Behaviour lives in slimmers (`./slimmers`), markup in renderer slimmers
+             * (`./slimmers/renderers`) and derivation in `./view-model` — see
+             * `src/slimmer/README.md`.
+             */
+            "uds-pattern-login-card": LocalJSX.IntrinsicElements["uds-pattern-login-card"] & JSXBase.HTMLAttributes<HTMLUdsPatternLoginCardElement>;
+            /**
+             * Full-page layout shell for authentication screens: branded masthead, a
+             * centred content column sized for `uds-pattern-login-card`, and an optional legal
+             * footer.
+             * It exists so consuming portals do not re-implement the same centred,
+             * responsive, brandable login layout for every product.
+             */
+            "uds-pattern-login-page": LocalJSX.IntrinsicElements["uds-pattern-login-page"] & JSXBase.HTMLAttributes<HTMLUdsPatternLoginPageElement>;
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export { DEFAULT_LOGIN_LABELS, formatLabel } from './utils/labels';
+export { createAuthProvider } from './providers/auth-provider';
+export { createMemoryAuthProvider } from './providers/memory-auth-provider';
+export { createControlStrategy, fail, goTo, stay } from './providers/control-strategy';
+export { createLoginConfig } from './providers/login-config';
+export type { UdsLoginConfig } from './providers/login-config';
+export type { MemoryAuthOptions, MemoryAuthUser } from './providers/memory-auth-provider';
+export type { UdsAuthErrorCode, UdsAuthProvider, UdsAuthResult, UdsMfaMethod, UdsSession, } from './providers/auth-provider';
+export type { UdsInterceptor, UdsLoginCompleteContext, UdsLoginControlStrategy, UdsLoginFailureContext, UdsLoginFailureOutcome, UdsLoginNavigateContext, UdsLoginNavigationCause, UdsLoginSubmitContext, UdsLoginTransition, UdsLoginTransitionContext, UdsLoginValues, } from './providers/control-strategy';
+export type { UdsLoginAction, UdsLoginActionDetail, UdsLoginErrorDetail, UdsLoginErrorLabels, UdsLoginLabels, UdsLoginStep, UdsLoginStepChangeDetail, } from './utils/types';