@3ddv/software-division-components 1.5.0 → 2.0.0

package/dist/types/3ddv-software-division-components-dvm-popover.d.ts

@@ -0,0 +1,456 @@
+import * as i0 from '@angular/core';
+import { ElementRef, ComponentRef, ViewContainerRef, Type, TemplateRef, OnInit, InjectionToken, OnDestroy, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { MapViewerNode } from '@3ddv/dvm-internal';
+import { ComputePositionConfig, OffsetOptions, ShiftOptions, FlipOptions, ArrowOptions, SizeOptions, AutoPlacementOptions, HideOptions, InlineOptions, DetectOverflowOptions, VirtualElement, Placement } from '@floating-ui/dom';
+import { Observable } from 'rxjs';
+import { Viewer3dService, MapViewerService } from '@3ddv/ngx-dvm-internal';
+
+type PopoverPlacement = Placement;
+interface PopoverInstance<T = unknown> {
+    id: string;
+    element: HTMLElement;
+    reference: HTMLElement | Element | VirtualElement | (ElementRef & VirtualElement);
+    componentRef?: ComponentRef<T>;
+    update?: () => void;
+    cleanup?: () => void;
+}
+interface PopoverOptions extends Omit<ComputePositionConfig, 'middleware'> {
+    middleware?: MiddlewareOptions;
+}
+interface MiddlewareOptions {
+    offset?: OffsetOptions;
+    shift?: ShiftOptions;
+    flip?: FlipOptions;
+    arrow?: ArrowOptions;
+    size?: SizeOptions;
+    autoPlacement?: AutoPlacementOptions;
+    hide?: HideOptions;
+    inline?: InlineOptions;
+    detectOverflow?: DetectOverflowOptions;
+}
+declare enum AppNodes {
+    Section = "section",
+    Row = "row",
+    Seat = "seat",
+    Ga = "general_admission",
+    Vip = "vip"
+}
+interface SeatPopoverData {
+    id: string;
+    section: string;
+    row: string;
+    seat: string;
+    price: number;
+    thumbnail?: string;
+}
+interface SectionPopoverData {
+    id: string;
+    section: string;
+    priceRange: {
+        min: number;
+        max: number;
+    };
+    availableQuantity: number;
+    adaQuantity: number;
+    thumbnail?: string;
+    type?: 'section' | 'general_admission';
+    isSelectedForBA?: boolean;
+    priceRangeWithFees?: string;
+}
+interface IThumbnailProvider {
+    getThumbnail(nodeId: string): Observable<string>;
+}
+interface IPopoverPositioner {
+    calculatePlacement(node: MapViewerNode, container: HTMLElement): Placement;
+    calculateOffset(node: MapViewerNode): number[];
+}
+interface IPopoverManager {
+    showPopover<T>(config: PopoverConfig<T>): void;
+    hidePopover(nodeId: string): void;
+    clearAll(): void;
+}
+interface PopoverConfig<T> {
+    nodeId: string;
+    node: MapViewerNode;
+    container: ViewContainerRef;
+    tooltip: HTMLElement;
+    containerElement: HTMLElement;
+    component: Type<T>;
+    componentInputs?: Partial<T>;
+    eventHandlers?: Record<string, (...args: any[]) => void>;
+}
+
+interface PopoverContentProjection {
+    thumbnail?: TemplateRef<unknown> | string;
+    content?: TemplateRef<unknown> | string;
+    price?: TemplateRef<unknown> | string;
+}
+interface PopoverServiceOptions {
+    providers?: any[];
+}
+declare class PopoverService {
+    private readonly appReference;
+    private readonly envInjector;
+    private readonly document;
+    private readonly popoverInstances;
+    private readonly popoverOptions;
+    private popoverTimerTimeInMs;
+    private currentPopoverId;
+    private popoverTimer;
+    private popoverInstancesWithTimers;
+    private readonly defaultMockProviders;
+    setTimer(): void;
+    clearTimer(): void;
+    /**
+     * Sets a timer for a specific popover instance to auto-hide it after the specified delay.
+     * @param popoverId - The ID of the popover to set timer for
+     * @param delayMs - Delay in milliseconds (optional, defaults to configured delay)
+     */
+    setPopoverTimer(popoverId: string, delayMs?: number): void;
+    /**
+     * Clears the timer for a specific popover instance.
+     * @param popoverId - The ID of the popover to clear timer for
+     */
+    clearPopoverTimer(popoverId: string): void;
+    /**
+     * Configures the default timer delay for popovers.
+     * @param delayMs - Delay in milliseconds
+     */
+    setTimerDelay(delayMs: number): void;
+    /**
+     * Crea un popover y lo añade al DOM, usando un elemento de referencia y contenido HTML o string.
+     * Si ya existe un popover con el mismo ID, lo destruye antes de crear uno nuevo.
+     *
+     * @param popoverId   Identificador único del popover.
+     * @param reference   Elemento de referencia para posicionar el popover (HTMLElement, Element, VirtualElement o ElementRef).
+     * @param content     Contenido del popover (HTMLElement o string HTML).
+     * @param options     Opciones de configuración para el posicionamiento (placement, strategy, middleware, etc).
+     * @returns           Instancia del popover creado.
+     */
+    createPopover(popoverId: string, reference: HTMLElement | Element | VirtualElement | (ElementRef & VirtualElement), content: HTMLElement | string, options?: Partial<PopoverOptions>): PopoverInstance<unknown>;
+    /**
+     * Crea un popover que contiene un componente Angular con soporte para proyección de contenido.
+     * Si ya existe un popover con el mismo ID, lo destruye antes de crear uno nuevo.
+     *
+     * @param popoverId   Identificador único del popover.
+     * @param reference   Elemento de referencia para posicionar el popover (HTMLElement, Element, VirtualElement o ElementRef).
+     * @param component   Clase del componente Angular a renderizar dentro del popover.
+     * @param inputs      Propiedades de entrada para el componente.
+     * @param contentProjection Contenido proyectado para los slots del popover.
+     * @param options     Opciones de configuración para el posicionamiento (placement, strategy, middleware, etc).
+     * @returns           Instancia del popover creado, incluyendo la referencia al componente.
+     */
+    createPopoverComponentWithContent<T>(popoverId: string, reference: HTMLElement | Element | VirtualElement | (ElementRef & VirtualElement), component: new (...arguments_: unknown[]) => T, inputs?: Partial<T>, contentProjection?: PopoverContentProjection, options?: Partial<PopoverOptions>, serviceOptions?: PopoverServiceOptions): PopoverInstance;
+    /**
+     * Crea un popover que contiene un componente Angular, lo añade al DOM y lo posiciona.
+     * Si ya existe un popover con el mismo ID, lo destruye antes de crear uno nuevo.
+     *
+     * @param popoverId   Identificador único del popover.
+     * @param reference   Elemento de referencia para posicionar el popover (HTMLElement, Element, VirtualElement o ElementRef).
+     * @param component   Clase del componente Angular a renderizar dentro del popover.
+     * @param inputs      Propiedades de entrada para el componente.
+     * @param options     Opciones de configuración para el posicionamiento (placement, strategy, middleware, etc).
+     * @returns           Instancia del popover creado, incluyendo la referencia al componente.
+     */
+    createPopoverComponent<T>(popoverId: string, reference: HTMLElement | Element | VirtualElement | (ElementRef & VirtualElement), component: new (...arguments_: unknown[]) => T, inputs?: Partial<T>, options?: Partial<PopoverOptions>, serviceOptions?: PopoverServiceOptions): PopoverInstance;
+    /**
+     * Destruye un popover existente por su ID, eliminando su elemento del DOM y limpiando recursos.
+     *
+     * @param id  Identificador del popover a destruir.
+     */
+    destroyPopover(id: string): void;
+    /**
+     * Destruye todos los popovers existentes, eliminando sus elementos del DOM y limpiando recursos.
+     */
+    destroyAllPopovers(): void;
+    /**
+     * Crea el elemento HTML base del popover, opcionalmente con contenido.
+     *
+     * @param content  Contenido a insertar en el popover (string, HTMLElement o ElementRef).
+     * @returns        Elemento HTML del popover.
+     */
+    private createPopoverElement;
+    /**
+     * Verifica si existe una instancia de popover con el ID dado y la destruye si es así.
+     *
+     * @param id  Identificador del popover a comprobar.
+     */
+    private checkPopoverInstance;
+    /**
+     * Calcula y aplica la posición del popover respecto a su elemento de referencia,
+     * usando las opciones de Floating UI.
+     *
+     * @param instance  Instancia del popover a posicionar.
+     * @param options   Opciones de configuración para el posicionamiento.
+     */
+    private calculatePosition;
+    /**
+     * Procesa la proyección de contenido para el componente popover.
+     *
+     * @param componentRef Referencia al componente creado
+     * @param contentProjection Contenido a proyectar en los slots
+     */
+    private processContentProjection;
+    /**
+     * Establece la proyección de contenido para un slot específico.
+     *
+     * @param componentInstance Instancia del componente
+     * @param projectionFlag Flag que indica si hay proyección
+     * @param content Contenido a proyectar
+     */
+    private setContentProjection;
+    /**
+     * Set Middlewares
+     * Método que recibe un objeto de opciones de middleware y devuelve un array de middlewares cargados con sus opciones.
+     *
+     * Para ello, necesitamos establecer un orden de aplicación de los middlewares, ya que la computación de la posición
+     * depende del estado de los middlewares aplicados anteriormente. Además, como son funciones, hacemos switch para
+     * cargar el middleware correspondiente en cada caso a excepción de detectOverflow, que es un middleware especial
+     * que no se aplica directamente, sino que se ejecuta como una función asíncrona sobre el estado devuelto de los middlewares (si los hay).
+     *
+     * @param middleware
+     * @returns {Middleware[]}
+     */
+    private setMiddlewares;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverService>;
+}
+
+declare class PopoverComponent implements OnInit {
+    /**
+     * The node to attach the popover to.
+     */
+    readonly node: MapViewerNode;
+    /**
+     * The current theme applied to the component.
+     */
+    readonly theme: i0.InputSignal<"theme-backoffice" | "theme-sdc">;
+    /**
+     * Emitted when the 3D view should be loaded.
+     */
+    readonly load3dView: i0.OutputEmitterRef<{
+        node: MapViewerNode;
+        section: string | undefined;
+    }>;
+    /**
+     * Emitted when a section should be selected/deselected for best available.
+     */
+    readonly selectSectionForBA: i0.OutputEmitterRef<{
+        node: MapViewerNode;
+        section: string | undefined;
+        selected: boolean;
+    }>;
+    /**
+     * Emitted when the seat map should be opened.
+     */
+    readonly openSeatMap: i0.OutputEmitterRef<{
+        node: MapViewerNode;
+        section: string | undefined;
+    }>;
+    private readonly dvm;
+    private readonly cdr;
+    private readonly format;
+    private readonly configurationService;
+    protected readonly popoverService: PopoverService;
+    protected readonly Nodes: typeof AppNodes;
+    protected thumbnail: string | undefined;
+    protected section: string | undefined;
+    protected row: string | undefined;
+    protected seat: string | undefined;
+    protected prices: string[] | undefined;
+    protected availableQuantity: number;
+    protected adaQuantity: number;
+    protected includedSectionForBA: boolean;
+    protected get seatData(): SeatPopoverData | null;
+    protected get sectionData(): SectionPopoverData | null;
+    ngOnInit(): void;
+    protected onEnter(_: MouseEvent): void;
+    protected onLeave(_: MouseEvent): void;
+    protected get price(): string | undefined;
+    protected get priceRange(): string;
+    private initComponent;
+    private setTexts;
+    private getThumbnail;
+    protected onLoad3dView(): void;
+    protected onSelectSectionForBA(selected: boolean): void;
+    protected onOpenSeatMap(): void;
+    private transformToSeatData;
+    private transformToSectionData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "sdc-map-popover", never, { "node": { "alias": "node"; "required": false; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; }, { "load3dView": "load3dView"; "selectSectionForBA": "selectSectionForBA"; "openSeatMap": "openSeatMap"; }, never, never, true, never>;
+}
+
+type Configuration = {
+    dvmData: {
+        venueId: string;
+    };
+};
+type IDvmFormatter = {
+    transform(value: string, ...args: unknown[]): string;
+};
+type IConfigurationService = {
+    configuration: Configuration;
+};
+type IDvmService = {
+    readonly viewer3dService: Viewer3dService;
+    readonly viewerService: MapViewerService;
+};
+declare const DVM_FORMATTER: InjectionToken<IDvmFormatter>;
+declare const CONFIGURATION_SERVICE: InjectionToken<IConfigurationService>;
+declare const DVM_SERVICE: InjectionToken<IDvmService>;
+declare const THUMBNAIL_PROVIDER: InjectionToken<IThumbnailProvider>;
+declare const POPOVER_POSITIONER: InjectionToken<IPopoverPositioner>;
+declare const POPOVER_MANAGER: InjectionToken<IPopoverManager>;
+
+/**
+ * Base component for popovers that provides timer functionality.
+ * Extend this component to create timer-aware popovers.
+ */
+declare abstract class BasePopoverComponent implements OnInit, OnDestroy {
+    popoverId: string;
+    autoHideDelay: number;
+    enableAutoHide: boolean;
+    mouseEnter: EventEmitter<MouseEvent>;
+    mouseLeave: EventEmitter<MouseEvent>;
+    popoverHidden: EventEmitter<void>;
+    protected readonly popoverService: PopoverService;
+    protected readonly cdr: ChangeDetectorRef;
+    private isMouseOver;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onMouseEnter(event: MouseEvent): void;
+    protected onMouseLeave(event: MouseEvent): void;
+    protected hidePopover(): void;
+    private startAutoHideTimer;
+    private clearAutoHideTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasePopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BasePopoverComponent, "ng-component", never, { "popoverId": { "alias": "popoverId"; "required": false; }; "autoHideDelay": { "alias": "autoHideDelay"; "required": false; }; "enableAutoHide": { "alias": "enableAutoHide"; "required": false; }; }, { "mouseEnter": "mouseEnter"; "mouseLeave": "mouseLeave"; "popoverHidden": "popoverHidden"; }, never, never, true, never>;
+}
+
+declare class SeatPopoverComponent extends BasePopoverComponent implements OnInit {
+    data: SeatPopoverData;
+    showLoader: boolean;
+    private readonly thumbnailProvider;
+    protected readonly cdr: ChangeDetectorRef;
+    protected thumbnail?: string;
+    protected isLoadingThumbnail: boolean;
+    ngOnInit(): void;
+    private loadThumbnail;
+    protected get formattedSection(): string;
+    protected get formattedSeat(): string;
+    protected onEnter(event: MouseEvent): void;
+    protected onLeave(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeatPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SeatPopoverComponent, "sdc-seat-popover", never, { "data": { "alias": "data"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SectionPopoverComponent extends BasePopoverComponent implements OnInit {
+    data: SectionPopoverData;
+    showLoader: boolean;
+    showBestAvailable: boolean;
+    showOpenSeatMap: boolean;
+    excludeSeatMapSections: string[];
+    isTicketFeeEnabled: boolean;
+    load3dView: EventEmitter<void>;
+    selectForBA: EventEmitter<boolean>;
+    openSeatMap: EventEmitter<void>;
+    private readonly thumbnailProvider;
+    protected readonly cdr: ChangeDetectorRef;
+    protected thumbnail?: string;
+    protected isLoadingThumbnail: boolean;
+    ngOnInit(): void;
+    private loadThumbnail;
+    protected get priceRangeDisplay(): string;
+    protected get priceRangeWithFees(): string | undefined;
+    protected get shouldShowSeatMapButton(): boolean;
+    protected onEnter(event: MouseEvent): void;
+    protected onLeave(event: MouseEvent): void;
+    protected onLoad3dView(): void;
+    protected onSelectForBA(): void;
+    protected onOpenSeatMap(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionPopoverComponent, "sdc-section-popover", never, { "data": { "alias": "data"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "showBestAvailable": { "alias": "showBestAvailable"; "required": false; }; "showOpenSeatMap": { "alias": "showOpenSeatMap"; "required": false; }; "excludeSeatMapSections": { "alias": "excludeSeatMapSections"; "required": false; }; "isTicketFeeEnabled": { "alias": "isTicketFeeEnabled"; "required": false; }; }, { "load3dView": "load3dView"; "selectForBA": "selectForBA"; "openSeatMap": "openSeatMap"; }, never, never, true, never>;
+}
+
+/**
+ * Generic popover manager service that handles popover lifecycle and positioning.
+ * This service is DVM-agnostic and delegates positioning logic to IPopoverPositioner.
+ */
+declare class PopoverManagerService implements IPopoverManager {
+    private currentPopoverId;
+    private tooltip?;
+    private readonly positioner;
+    constructor(positioner: IPopoverPositioner);
+    /**
+     * Shows a popover with the specified configuration.
+     * @param config - Configuration for the popover including component, data, and positioning
+     */
+    showPopover<T>(config: PopoverConfig<T>): void;
+    /**
+     * Hides the popover for the specified node ID.
+     * @param nodeId - The node ID of the popover to hide
+     */
+    hidePopover(nodeId: string): void;
+    /**
+     * Clears all popovers.
+     */
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverManagerService>;
+}
+
+/**
+ * DVM-specific positioning service for popovers.
+ * Handles calculation of popover placement and offset based on DVM node properties.
+ */
+declare class DvmPopoverPositionerService implements IPopoverPositioner {
+    private readonly dvmService;
+    private readonly configService;
+    constructor(dvmService: IDvmService, configService: IConfigurationService);
+    /**
+     * Calculates the optimal placement for a popover based on node position.
+     * @param node - The MapViewerNode to position relative to
+     * @param container - The container element for positioning reference
+     * @returns The calculated placement ('top' or 'bottom')
+     */
+    calculatePlacement(node: MapViewerNode, container: HTMLElement): Placement;
+    /**
+     * Calculates the offset for popover positioning based on node type and configuration.
+     * @param node - The MapViewerNode to calculate offset for
+     * @returns An array of [x, y] offset values
+     */
+    calculateOffset(node: MapViewerNode): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DvmPopoverPositionerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DvmPopoverPositionerService>;
+}
+
+/**
+ * Abstract base class for transforming data from source format to target popover format.
+ * Apps can extend this class to implement their own data transformation logic.
+ */
+declare abstract class BasePopoverDataTransformer<TSource, TTarget> {
+    /**
+     * Transforms source data to target popover data format.
+     * @param source - The source data to transform
+     * @param context - Optional context for additional transformation logic
+     * @returns The transformed data in target format
+     */
+    abstract transform(source: TSource, context?: any): TTarget;
+}
+/**
+ * Abstract base class for transforming seat data to SeatPopoverData format.
+ * Apps should extend this class and implement the transform method with their
+ * specific seat data models.
+ */
+declare abstract class BaseSeatDataTransformer<TSource> extends BasePopoverDataTransformer<TSource, SeatPopoverData> {
+}
+/**
+ * Abstract base class for transforming section data to SectionPopoverData format.
+ * Apps should extend this class and implement the transform method with their
+ * specific section data models.
+ */
+declare abstract class BaseSectionDataTransformer<TSource> extends BasePopoverDataTransformer<TSource, SectionPopoverData> {
+}
+
+export { AppNodes, BasePopoverComponent, BasePopoverDataTransformer, BaseSeatDataTransformer, BaseSectionDataTransformer, CONFIGURATION_SERVICE, DVM_FORMATTER, DVM_SERVICE, DvmPopoverPositionerService, POPOVER_MANAGER, POPOVER_POSITIONER, PopoverComponent, PopoverManagerService, PopoverService, SeatPopoverComponent, SectionPopoverComponent, THUMBNAIL_PROVIDER };
+export type { Configuration, IConfigurationService, IDvmFormatter, IDvmService, IPopoverManager, IPopoverPositioner, IThumbnailProvider, MiddlewareOptions, PopoverConfig, PopoverContentProjection, PopoverInstance, PopoverOptions, PopoverPlacement, PopoverServiceOptions, SeatPopoverData, SectionPopoverData };

package/dist/types/3ddv-software-division-components-dvm-stepper.d.ts

@@ -0,0 +1,34 @@
+import * as _angular_core from '@angular/core';
+import { Size } from '@3ddv/software-division-components/shared';
+
+type Step = {
+    action: string;
+    name: string;
+};
+type StepState = 'normal' | 'active' | 'completed';
+
+declare class StepperComponent {
+    readonly steps: _angular_core.InputSignal<Step[]>;
+    readonly size: _angular_core.InputSignal<Size>;
+    readonly routeName: _angular_core.InputSignal<string | null>;
+    readonly theme: _angular_core.InputSignal<"theme-backoffice" | "theme-sdc">;
+    readonly variant: _angular_core.InputSignal<"light" | "dark">;
+    /** Only these are supported for stepper. */
+    private readonly supportedSizes;
+    /** Normalize any Size → StepperSize by flooring to the nearest supported size. */
+    private normalizeSize;
+    private readonly allowedAlign;
+    private readonly allowedOrientation;
+    private readonly allowedSizes;
+    readonly styleClass: _angular_core.InputSignal<string[]>;
+    readonly className: _angular_core.InputSignal<string>;
+    private readonly _validatedStyleClass;
+    private readonly _effectiveSize;
+    protected readonly computedClass: _angular_core.Signal<string>;
+    protected stateForIndex(i: number): StepState;
+    protected stateClass(i: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepperComponent, "sdc-stepper", never, { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "routeName": { "alias": "routeName"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { StepperComponent };

package/dist/types/3ddv-software-division-components-dvm-ticket-info-item.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from '@angular/core';
+
+declare class TicketInfoItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TicketInfoItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TicketInfoItemComponent, "sdc-ticket-info-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class TicketInfoItemService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TicketInfoItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TicketInfoItemService>;
+}
+
+export { TicketInfoItemComponent, TicketInfoItemService };

package/dist/types/3ddv-software-division-components-generic-add-digital-wallet.d.ts

@@ -0,0 +1,23 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { BraintreePayload } from '@3ddv/software-division-components/generic/braintree';
+import { FormControl } from '@angular/forms';
+
+declare class AddDigitalWalletComponent implements OnInit {
+    token: _angular_core.InputSignal<string>;
+    errorMessage: _angular_core.InputSignal<string | null>;
+    showCancelButton: _angular_core.InputSignal<boolean>;
+    showIsDefaultCardCheckbox: _angular_core.InputSignal<boolean>;
+    readonly braintreePayload: _angular_core.OutputEmitterRef<BraintreePayload>;
+    readonly cancelClick: _angular_core.OutputEmitterRef<void>;
+    readonly useDefaultCard: _angular_core.OutputEmitterRef<boolean>;
+    useDefaultCardCtrl: FormControl<boolean | null>;
+    private readonly destroyRef;
+    ngOnInit(): void;
+    onDigitalWalletSubmitted(data: BraintreePayload): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddDigitalWalletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddDigitalWalletComponent, "sdc-add-digital-wallet", never, { "token": { "alias": "token"; "required": true; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "showCancelButton": { "alias": "showCancelButton"; "required": false; "isSignal": true; }; "showIsDefaultCardCheckbox": { "alias": "showIsDefaultCardCheckbox"; "required": false; "isSignal": true; }; }, { "braintreePayload": "braintreePayload"; "cancelClick": "cancelClick"; "useDefaultCard": "useDefaultCard"; }, never, never, true, never>;
+}
+
+export { AddDigitalWalletComponent };

package/dist/types/3ddv-software-division-components-generic-braintree.d.ts

@@ -0,0 +1,62 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef } from '@angular/core';
+
+interface BraintreePayload {
+    type: string;
+    nonce: string;
+    description: string;
+    details: BraintreeDetails;
+    binData: BraintreeBinData;
+}
+interface BraintreeDetails {
+    bin: string;
+    lastTwo: string;
+    lastFour: string;
+    cardType: string;
+    expirationYear: string;
+    expirationMonth: string;
+}
+interface BraintreeBinData {
+    debit: string;
+    prepaid: string;
+    payroll: string;
+    productId: string;
+    commercial: string;
+    healthcare: string;
+    issuingBank: string;
+    durbinRegulated: string;
+    countryOfIssuance: string;
+}
+
+/**
+ * Braintree Drop‑in component that auto‑wires clicks
+ * on the first projected element and errors if more than one.
+ * Recreates the drop‑in UI whenever isDigitalWalletPayment changes,
+ * ensuring the container is empty before initialization.
+ */
+declare class BraintreeComponent implements OnDestroy {
+    private readonly elRef;
+    /** Braintree element reference */
+    braintreeContainer: _angular_core.Signal<ElementRef<any> | undefined>;
+    /** Braintree client token input */
+    readonly token: _angular_core.InputSignal<string>;
+    /** Toggle to require cardholder name */
+    readonly isDigitalWalletPayment: _angular_core.InputSignal<boolean>;
+    /** Emits when a payment payload is ready */
+    readonly onSubmit: _angular_core.OutputEmitterRef<BraintreePayload>;
+    /** Holds the Drop‑in instance */
+    private dropinInstance;
+    constructor(elRef: ElementRef);
+    ngOnDestroy(): void;
+    /** Clears previous drop-in UI and recreates it */
+    private initializeDropin;
+    /** Requests payment method and emits payload */
+    private requestPayment;
+    /** Tears down the drop-in instance if present */
+    private teardownDropin;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BraintreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BraintreeComponent, "sdc-braintree", never, { "token": { "alias": "token"; "required": true; "isSignal": true; }; "isDigitalWalletPayment": { "alias": "isDigitalWalletPayment"; "required": false; "isSignal": true; }; }, { "onSubmit": "onSubmit"; }, never, ["*"], true, never>;
+}
+
+export { BraintreeComponent };
+export type { BraintreeBinData, BraintreeDetails, BraintreePayload };