@liquidcommerce/elements-sdk 2.6.0-beta.13 → 2.6.0-beta.130

package/dist/types/modules/checkout/checkout.commands.d.ts

@@ -1,23 +1,94 @@
 import { BaseCommand } from '@/core/command/base-command.service';
-import type { ICheckoutBillingStore, ICheckoutCustomerStore, ICheckoutGiftRecipientStore, ICheckoutPaymentMethodStore } from '@/core/store/interfaces/checkout.interface';
+import type { ICheckoutDetailsEventData } from '@/core/pubsub/interfaces/checkout.interface';
+import type { ICheckoutPaymentMethodStore } from '@/core/store/interfaces/checkout.interface';
+import type { FulfillmentType } from '@/enums';
+import type { CheckoutPaymentSessionType, ICheckoutBilling, ICheckoutCustomer, ICheckoutGiftRecipient, ICheckoutMarketingPreferences, ICheckoutPaymentSession, ICheckoutPrepare } from '@/interfaces/api/checkout.interface';
+import type { DeliverySlot } from '@/interfaces/api/delivery.interface';
+import type { AddItemParams } from '@/modules/cart/cart.commands';
+import type { PresaleExpiredReason } from '@/modules/checkout/components';
+import { type IExpressWalletBillingDetails } from '@/modules/checkout/express-wallet';
+import type { StripeJsLoadFailure } from '@/modules/checkout/stripe-js';
 export declare class CheckoutCommands extends BaseCommand {
     private readonly uiCommands;
-    private readonly commonCommands;
+    private lastLoadParams;
+    private paymentGeneration;
+    private savedMarketingPreferences;
+    private savedMarketingRevision;
+    private marketingNeedsPrepare;
+    private completingCheckout;
+    private savedMarketingError;
+    private marketingEdits;
+    private marketingQueue;
+    private readonly marketingFields;
+    private customerEditRevision;
+    private customerEditedGeneration;
+    private confirmedPayment;
+    private offeredDeliverySlots;
+    private offeredDeliveryAddress;
+    private savingDeliverySelection;
+    private expressHandoff;
+    private get requiresBirthDate();
+    assertPaymentReady(): void;
+    private assertDeliveryScheduleReady;
+    private lapsedDeliveryWindowIds;
+    private clearLapsedDeliveryWindows;
+    private offeredSlots;
+    private findOfferedDeliverySlot;
+    loadDeliverySlots(fulfillmentId: string): Promise<DeliverySlot[]>;
+    chooseDeliverySlot(fulfillmentId: string, slotId: string | null): Promise<void>;
+    private completionError;
+    private dropDeliveryScheduling;
+    private forgetDeliveryWindow;
+    private assertDeliverySlotChoosable;
+    private responseFulfillments;
+    private findResponseFulfillment;
+    private withDeliverySlotDetails;
+    private responseFulfillmentIds;
+    private expiredDeliveryMarksWith;
+    private pruneExpiredDeliveryWindows;
+    private expireDeliveryWindows;
+    private prepareWithWindowRecovery;
+    retryLoadCheckout(): Promise<void>;
+    private paymentSessionRequest;
     constructor();
     static getInstance(): CheckoutCommands;
-    loadCheckout(cartIdParam?: string): Promise<void>;
+    addPresaleItem(params: AddItemParams): Promise<void>;
+    loadCheckout(params: {
+        checkoutId?: string;
+        cartId?: string;
+        isForPresale?: boolean;
+    }): Promise<void>;
+    private showAlreadyCompletedCheckout;
+    loadCheckoutFromResponse(response: ICheckoutPrepare): void;
     toggleIsGift(active?: boolean): Promise<void>;
     toggleBillingSameAsShipping(active?: boolean): Promise<void>;
-    toggleMarketingPreferences(fieldName: 'canEmail' | 'canSms', active?: boolean): Promise<void>;
+    private loadedMarketingState;
+    private defaultMarketingPreferences;
+    private marketingForPrepare;
+    private confirmedSavedMarketing;
+    private queueMarketing;
+    setSavedMarketingPreferences(preferences: Partial<ICheckoutMarketingPreferences>): Promise<void>;
+    clearSavedMarketingPreferences(): void;
+    private recordSavedMarketing;
+    private assertMarketingRestored;
+    private canApplySavedMarketing;
+    private applySavedMarketingPreferences;
+    toggleMarketingPreferences(fieldName: 'canEmail' | 'canSms', active?: boolean): Promise<boolean>;
     getPaymentSession(): Promise<void>;
-    confirmPaymentSession(confirmationTokenId: string, setupIntentId: string): Promise<ICheckoutPaymentMethodStore | null>;
+    reportPaymentFormFailure(reason: StripeJsLoadFailure, cause?: unknown): void;
+    getExpressPaymentSession(): Promise<ICheckoutPaymentSession | null>;
+    private requestPaymentSession;
+    confirmPaymentSession(confirmationTokenId: string, setupIntentId: string, sessionType?: CheckoutPaymentSessionType): Promise<ICheckoutPaymentMethodStore>;
     applyPromoCode(code: string): Promise<void>;
     removePromoCode(): Promise<void>;
     clearPromoCodeError(): Promise<void>;
     applyGiftCard(code: string): Promise<void>;
     removeGiftCard(code: string): Promise<void>;
     clearGiftCardError(): Promise<void>;
-    openPresaleExpiredDrawer(): void;
+    showPresaleExpired(reason?: PresaleExpiredReason): void;
+    openCheckout(): void;
+    getReturnUrl(): string | null;
+    private resolveCheckoutPageUrl;
     rerenderCheckout(): void;
     updateCheckoutItemQuantity(itemId: string, delta: number): Promise<void>;
     removeItemEngraving(productItemId: string): Promise<void>;
@@ -26,28 +97,73 @@ export declare class CheckoutCommands extends BaseCommand {
     updateFulfillmentTip(fulfillmentId: string, tipAmount: number): Promise<void>;
     removeFulfillmentTip(fulfillmentId: string): Promise<void>;
     clearCheckoutError(): Promise<void>;
+    markCustomerFormEdited(): void;
+    canPrefillCustomerForm(): boolean;
+    savePrefilledCustomerInfo(): Promise<void>;
     editCustomerForm(): Promise<void>;
     saveCustomerForm({ shippingAddressTwo, deliveryInstructions, customerData, }: {
-        customerData: ICheckoutCustomerStore;
+        customerData: ICheckoutCustomer;
         shippingAddressTwo: string;
         deliveryInstructions: string;
     }): Promise<void>;
     editGiftRecipientForm(): Promise<void>;
-    saveGiftRecipientForm({ shippingAddressTwo, deliveryInstructions, ...giftRecipientData }: ICheckoutGiftRecipientStore & {
+    saveGiftRecipientForm({ shippingAddressTwo, deliveryInstructions, ...giftRecipientData }: ICheckoutGiftRecipient & {
         shippingAddressTwo: string;
         deliveryInstructions: string;
     }): Promise<void>;
     editPaymentForm(): Promise<void>;
+    private resetCheckoutPreservingInjected;
+    private markInjectedPaymentReady;
     savePaymentForm({ billingFormData, paymentSession, }: {
-        billingFormData?: ICheckoutBillingStore;
+        billingFormData?: ICheckoutBilling;
         paymentSession?: {
             confirmationTokenId: string;
             setupIntentId: string;
+            sessionType?: CheckoutPaymentSessionType;
         };
     }): Promise<void>;
-    checkoutComplete(): Promise<void>;
+    private prepareMarketingForCompletion;
+    beginExpressCompletion({ wallet, confirmationTokenId, intentId, approvedTotal, billingDetails, }: {
+        wallet: string;
+        confirmationTokenId: string;
+        intentId: string;
+        approvedTotal: number;
+        billingDetails: IExpressWalletBillingDetails | undefined;
+    }): Promise<void>;
+    private prepareExpressPayment;
+    completeExpressOrder(birthDate?: string): Promise<void>;
+    cancelExpressCompletion(): void;
+    private saveExpressCustomer;
+    private assertApprovedTotal;
+    private setExpressStatus;
+    private failExpressCompletion;
+    private writeExpress;
+    checkoutComplete(options?: {
+        expressPaymentIntentId?: string;
+    }): Promise<void>;
     private updateStoreFromCheckoutResponse;
-    private partialLoadCheckout;
+    private getDeliveryMethodLocation;
+    loadDeliveryMethods(): Promise<void>;
+    toggleDeliveryMethod(): void;
+    switchDeliveryMethod(fulfillmentType: FulfillmentType): Promise<void>;
+    private watchForReturnFromAddress;
+    relocateCheckout(): Promise<void>;
+    private requestFulfillment;
+    private deliveryMethodCarryOver;
+    private refreshPaymentAfterDeliveryMethodSwitch;
+    changeDeliveryLocation(trigger?: HTMLElement | null): void;
+    private syncFromItemUpdate;
+    private syncCheckoutState;
+    private refreshCheckout;
     private dataForCheckoutPrepare;
-    private buildCheckoutItemStore;
+    private normalizeForApi;
+    getDetails(): ICheckoutDetailsEventData;
+    trackBeginCheckout(): void;
+    trackPresaleCheckoutStart(): void;
+    reportExpressCheckoutStarted({ wallet, reportBeginCheckout }: {
+        wallet: string;
+        reportBeginCheckout: boolean;
+    }): void;
+    private checkoutItemsForAnalytics;
+    private toAnalyticsItem;
 }

package/dist/types/modules/checkout/checkout.component.d.ts

@@ -1,10 +1,16 @@
-import { BaseComponent } from '@/core/base-component.service';
+import { BaseComponent, type IOnStoreChanged } from '@/core/base-component.service';
 import type { ICheckoutComponent } from '@/interfaces/configs';
 export interface ICheckoutComponentParams {
     checkoutId: string;
     isIndependentComponent: boolean;
+    hideHeader: boolean;
 }
 export declare class CheckoutComponent extends BaseComponent<ICheckoutComponentParams, ICheckoutComponent> {
     constructor();
+    onStoreWatch(_changes: IOnStoreChanged[]): void;
+    private updateInitializationState;
+    afterRender(): void;
     protected template(): HTMLElement[];
+    private createAlerts;
+    private createHeader;
 }

package/dist/types/modules/checkout/components/checkout-billing.component.d.ts

@@ -1,13 +1,16 @@
 import { BaseComponent } from '@/core/base-component.service';
-import type { ICheckoutBillingStore } from '@/core/store/interfaces/checkout.interface';
+import type { ICheckoutBilling } from '@/interfaces/api/checkout.interface';
 import type { ICheckoutComponent } from '@/interfaces/configs';
 export interface ICheckoutBillingComponentParams {
-    isFormValid: (isValid: boolean, data: ICheckoutBillingStore) => void;
+    isFormValid: (isValid: boolean, data: ICheckoutBilling) => void;
 }
 export declare class CheckoutBillingComponent extends BaseComponent<ICheckoutBillingComponentParams, ICheckoutComponent> {
     private billingData;
     get hostClasses(): string[];
     constructor();
+    private pendingToggleFocus;
+    protected afterRender(): void;
+    private readonly onBillingSameAsShippingToggle;
     private billingSameAsShippingToggle;
     private updateSaveButtonState;
     protected template(): HTMLElement[];

package/dist/types/modules/checkout/components/checkout-buyer.component.d.ts

@@ -7,6 +7,7 @@ export declare class CheckoutBuyer extends BaseComponent<null, ICheckoutComponen
     get hostClasses(): string[];
     constructor();
     onStoreWatch(changes: IOnStoreChanged[]): void;
+    private get requiresBirthDate();
     private updateSaveButtonState;
     protected template(): HTMLElement[];
 }

package/dist/types/modules/checkout/components/checkout-completed.component.d.ts

@@ -1,13 +1,20 @@
 import { BaseComponent } from '@/core/base-component.service';
 import type { ICheckoutComponent } from '@/interfaces/configs';
+import type { PlacedDeliveryWindow } from '@/utils/delivery-scheduling';
 export interface ICheckoutCompletedComponentParams {
     orderNumber: string;
     orderTotal: number;
     cardLast4: string;
     customerEmail: string;
     giftRecipientEmail: string | null;
+    checkoutToken?: string;
+    cartId?: string;
+    isCompleted?: boolean;
+    deliveryWindows?: PlacedDeliveryWindow[];
 }
 export declare class CheckoutCompletedComponent extends BaseComponent<ICheckoutCompletedComponentParams, ICheckoutComponent> {
     get hostClasses(): string[];
+    private hasAnnouncedCompletion;
+    protected afterRender(): void;
     protected template(): HTMLElement[];
 }

package/dist/types/modules/checkout/components/checkout-deliver-to.component.d.ts

@@ -8,6 +8,7 @@ export declare class CheckoutDeliverToComponent extends BaseComponent<null, IChe
     get hostClasses(): string[];
     constructor();
     onStoreWatch(changes: IOnStoreChanged[]): void;
+    private get requiresBirthDate();
     private updateSaveButtonState;
     protected template(): HTMLElement[];
 }

package/dist/types/modules/checkout/components/checkout-delivery-method.component.d.ts

@@ -0,0 +1,22 @@
+import { BaseComponent } from '@/core/base-component.service';
+import type { ICheckoutComponent } from '@/interfaces/configs';
+export declare class CheckoutDeliveryMethodComponent extends BaseComponent<null, ICheckoutComponent> {
+    get hostClasses(): string[];
+    constructor();
+    protected connected(): void;
+    onStoreWatch(): void;
+    private hasOrderMoved;
+    private isSameAddress;
+    protected afterRender(): void;
+    protected template(): HTMLElement[];
+    private createHeader;
+    private createSummaryRow;
+    private createOptions;
+    private createOptionCard;
+    private createOptionTitleRow;
+    private describeOption;
+    private describeUnavailable;
+    private describeForScreenReader;
+    private createChangeLocationButton;
+    private formatFee;
+}

package/dist/types/modules/checkout/components/checkout-delivery-scheduling.component.d.ts

@@ -0,0 +1,51 @@
+import { BaseComponent } from '@/core/base-component.service';
+import type { ICheckoutComponent } from '@/interfaces/configs';
+export declare class CheckoutDeliverySchedulingComponent extends BaseComponent<null, ICheckoutComponent> {
+    private draft;
+    private dialog;
+    private paintScheduled;
+    private error;
+    private pendingFocus;
+    private restoreTrigger;
+    private releaseFocusTrap;
+    private readonly focusManager;
+    private handledExpired;
+    private loadToken;
+    private announcedNotice;
+    private timesScroll;
+    constructor();
+    private get busy();
+    private get expiredIds();
+    protected afterRender(): void;
+    protected onStoreChanged(): boolean;
+    private update;
+    private paint;
+    private showDialog;
+    private settle;
+    private keepTimeInView;
+    protected disconnected(): void;
+    private endPicker;
+    private draftFulfillment;
+    private openForNewlyExpired;
+    private dayKey;
+    private todayKey;
+    private draftScheduling;
+    private openPicker;
+    private loadSlots;
+    private whenIdle;
+    private closePicker;
+    private saveDraft;
+    private createGroup;
+    private get schedulingAllowed();
+    private summaryText;
+    private radio;
+    private createDates;
+    private createTimes;
+    private createNotice;
+    private createLoading;
+    private createDialogShell;
+    private fillDialog;
+    private captureViewState;
+    private createRows;
+    protected template(): HTMLElement[];
+}

package/dist/types/modules/checkout/components/checkout-express-checkout.component.d.ts

@@ -0,0 +1,63 @@
+import { BaseComponent } from '@/core/base-component.service';
+import type { ICheckoutComponent } from '@/interfaces/configs';
+export interface ICheckoutExpressCheckoutComponentParams {
+    variant?: 'section' | 'buttons';
+    isIndependentComponent?: boolean;
+}
+export declare class CheckoutExpressCheckoutComponent extends BaseComponent<ICheckoutExpressCheckoutComponentParams, ICheckoutComponent> {
+    private section;
+    private walletHost;
+    private completionElement;
+    private beginCheckoutReported;
+    private stripe;
+    private stripeElements;
+    private expressElement;
+    private sessionSecret;
+    private expressSession;
+    private sessionAmount;
+    private isMounting;
+    private isProcessing;
+    private hasAvailableWallets;
+    private availableWallets;
+    private hasSettledAvailability;
+    private scheduleReadyAtMount;
+    private lastPublishedAvailability;
+    get hostClasses(): string[];
+    constructor();
+    protected onStoreWatch(): void;
+    private syncCompletionView;
+    private get isCompletingExpress();
+    private get isButtonsOnly();
+    private get isReadyForPayment();
+    private get isDeliveryScheduleReady();
+    private get isGiftOrder();
+    protected template(): HTMLElement[];
+    protected afterRender(): void;
+    private createDividerLine;
+    private updateVisibility;
+    private publishAvailability;
+    private reportUnavailable;
+    private mountExpressElement;
+    private ensurePaymentSession;
+    private createWalletHost;
+    private findRootComponent;
+    private get orderTotal();
+    private buildElementsOptions;
+    private readIntentTerms;
+    private normaliseFutureUsage;
+    private buildAppearance;
+    private buildElementOptions;
+    private buildLineItems;
+    private readAvailability;
+    private handleAvailability;
+    private handleClick;
+    private hasUnmetMinimums;
+    private handleConfirm;
+    private isTotalUnchanged;
+    private toBillingDetails;
+    private failPayment;
+    private handleCancel;
+    private teardownExpressElement;
+    private remountIfTotalMoved;
+    protected disconnected(): void;
+}

package/dist/types/modules/checkout/components/checkout-express-completion.component.d.ts

@@ -0,0 +1,21 @@
+import { BaseComponent } from '@/core/base-component.service';
+import type { ICheckoutComponent } from '@/interfaces/configs';
+export declare class CheckoutExpressCompletionComponent extends BaseComponent<null, ICheckoutComponent> {
+    private birthDate;
+    private isBirthDateValid;
+    private completeButton;
+    private announcedState;
+    private hasFocusedHeading;
+    constructor();
+    get hostClasses(): string[];
+    private get express();
+    private get needsBirthDate();
+    protected afterRender(): void;
+    protected template(): HTMLElement[];
+    private headingFor;
+    private copyFor;
+    private createDots;
+    private createBirthDateInput;
+    private createCompleteButton;
+    private createBackLink;
+}

package/dist/types/modules/checkout/components/checkout-header.component.d.ts

@@ -2,6 +2,7 @@ import { BaseComponent } from '@/core/base-component.service';
 export interface ICheckoutHeaderParams {
     onClose?: () => void;
     onBackToCart?: () => void;
+    isHostedCheckout?: boolean;
 }
 export declare class CheckoutHeaderComponent extends BaseComponent<ICheckoutHeaderParams> {
     get hostClasses(): string[];

package/dist/types/modules/checkout/components/checkout-item-quantity.component.d.ts

@@ -9,8 +9,12 @@ export declare class CheckoutItemQuantityComponent extends BaseComponent<IChecko
     get hostClasses(): string[];
     constructor();
     onStoreWatch(changes: IOnStoreChanged[]): void;
+    private getCheckoutItemStore;
+    private getCartItemStore;
+    private getProductStoreByLiquidId;
     private getAvailableQuantity;
     private calculateQuantityLimits;
+    private get itemName();
     private updateButtonStates;
     private handleQuantityChange;
     protected template(): HTMLElement[];

package/dist/types/modules/checkout/components/checkout-item.component.d.ts

@@ -7,6 +7,8 @@ export declare class CheckoutItemComponent extends BaseComponent<ICheckoutItemCo
     get hostClasses(): string[];
     constructor();
     onStoreChanged(changes: IOnStoreChanged[]): boolean | undefined;
+    private deliveryExpectation;
+    private updateDeliveryExpectation;
     private updateEngravingElement;
     private setupMinimumPurchaseAlert;
     private updateTrashButtonState;

package/dist/types/modules/checkout/components/checkout-items.component.d.ts

@@ -1,14 +1,15 @@
 import { BaseComponent, type IOnStoreChanged } from '@/core/base-component.service';
 import type { ICheckoutComponent } from '@/interfaces/configs';
 export declare class CheckoutItemsComponent extends BaseComponent<null, ICheckoutComponent> {
+    private togglerElement;
+    private togglerButton;
+    private togglerLabel;
+    private itemsList;
     get hostClasses(): string[];
     constructor();
     private createItemElement;
-    private getItemsListContainer;
-    private getTogglerLabel;
     private getCurrentItemsMap;
     private syncItemsWithStore;
-    private updateItemCount;
     onStoreChanged(changes: IOnStoreChanged[]): boolean | undefined;
     private handleToggle;
     private setupToggler;

package/dist/types/modules/checkout/components/checkout-order-summary.component.d.ts

@@ -6,8 +6,11 @@ export declare class CheckoutOrderSummaryComponent extends BaseComponent<null, I
     onStoreWatch(changes: IOnStoreChanged[]): void;
     private updateZeroAmountElement;
     protected afterRender(): void;
+    private paintMarketingCheckbox;
+    private toggleMarketingPreference;
     private handleEmailToggle;
     private handleSmsToggle;
+    private updateSavedMarketingPrompts;
     private marketingOptInsContainer;
     private hasOnDemandOrder;
     protected template(): HTMLElement[];

package/dist/types/modules/checkout/components/checkout-payment.component.d.ts

@@ -5,9 +5,9 @@ export interface ICheckoutSendToFormComponentParams {
 }
 export declare class CheckoutPaymentComponent extends BaseComponent<ICheckoutSendToFormComponentParams, ICheckoutComponent> {
     private stripeHandlerElement;
-    private hardcodedPaymentElement;
     private saveButton;
     private errorMessageElement;
+    private walletInstructionsElement?;
     private billingFormData;
     private isValidBillingForm;
     private isBillingSameAsShipping;
@@ -17,10 +17,17 @@ export declare class CheckoutPaymentComponent extends BaseComponent<ICheckoutSen
     private isSavingPayment;
     get hostClasses(): string[];
     constructor();
+    private getInjectedPaymentMethod;
+    private scheduleReady;
+    private deliveryPaymentReady;
     onStoreWatch(changes: IOnStoreChanged[]): void;
     private handleBillingSameAsShippingChange;
     afterRender(): Promise<void>;
     private updateSaveButtonState;
+    private getSelectedWallet;
+    private getPaymentButtonText;
+    private updateWalletInstructions;
+    private lastAnnouncedPaymentError;
     private updateErrorMessage;
     private showError;
     protected template(): HTMLElement[];

package/dist/types/modules/checkout/components/checkout-place-order-button.component.d.ts

@@ -2,16 +2,12 @@ import { BaseComponent, type IOnStoreChanged } from '@/core/base-component.servi
 import type { ICheckoutComponent } from '@/interfaces/configs';
 export declare class CheckoutPlaceOrderButtonComponent extends BaseComponent<null, ICheckoutComponent> {
     private placeOrderButton;
-    private errorContainer;
-    private errorTimeoutId;
+    private lastButtonState;
     get hostClasses(): string[];
     constructor();
     afterRender(): void;
-    disconnected(): void;
     onStoreWatch(changes: IOnStoreChanged[]): void;
     private updateButtonState;
-    private clearErrorTimeout;
-    private updateErrorDisplay;
     private determineButtonState;
     private handlePlaceOrderClick;
     protected template(): HTMLElement[];

package/dist/types/modules/checkout/components/checkout-presale-countdown.component.d.ts

@@ -1,9 +1,13 @@
 import { BaseComponent, type IOnStoreChanged } from '@/core/base-component.service';
 export declare class CheckoutPresaleCountdownComponent extends BaseComponent<null> {
+    private static readonly DEFAULT_PRESALE_DURATION_SECONDS;
+    private static readonly ONE_MINUTE_THRESHOLD_SECONDS;
+    private static readonly COUNTDOWN_UPDATE_INTERVAL_MS;
     private countdownInterval;
     private expiresAt;
-    private totalDuration;
+    private initialDurationSeconds;
     private rootElement;
+    private lastRenderedTime;
     private scrollHandler;
     private scrollContainer;
     private isCurrentlyScrolled;
@@ -11,16 +15,26 @@ export declare class CheckoutPresaleCountdownComponent extends BaseComponent<nul
     get hostClasses(): string[];
     constructor();
     onStoreChanged(changes: IOnStoreChanged[]): boolean;
+    private resetCountdownState;
     protected afterRender(): void;
     protected disconnected(): void;
     private setupDrawerScrollDetection;
+    private findScrollContainer;
+    private setScrolledState;
     private isScrollable;
     private cleanupScrollListener;
     private updateExpiresAt;
     private startCountdown;
     private stopCountdown;
     private updateCountdown;
+    private updateWarningState;
+    private updateTimerDisplay;
+    private updateProgressBar;
     private formatTime;
     private handleExpire;
     protected template(): HTMLElement;
+    private createTextContainer;
+    private createHeader;
+    private createSubtitle;
+    private createProgressBar;
 }

package/dist/types/modules/checkout/components/checkout-presale-expired.component.d.ts

@@ -1,11 +1,17 @@
 import { BaseComponent } from '@/core/base-component.service';
 import type { ICheckoutComponent } from '@/interfaces/configs';
-export declare class CheckoutPresaleExpiredComponent extends BaseComponent<null, ICheckoutComponent> {
+export type PresaleExpiredReason = 'time_expired' | 'items_unavailable';
+export interface ICheckoutPresaleExpiredComponentParams {
+    reason: PresaleExpiredReason;
+}
+export declare class CheckoutPresaleExpiredComponent extends BaseComponent<ICheckoutPresaleExpiredComponentParams, ICheckoutComponent> {
     private autoCloseInterval;
     private autoCloseSeconds;
     private autoCloseElement;
     get hostClasses(): string[];
     get hostAttributes(): Record<string, string>;
+    private isItemsUnavailable;
+    private isTimeExpired;
     protected afterRender(): void;
     protected disconnected(): void;
     private handleExit;

package/dist/types/modules/checkout/components/checkout-prop65-warning.component.d.ts

@@ -0,0 +1,8 @@
+import { BaseComponent } from '@/core/base-component.service';
+import type { ICheckoutComponent } from '@/interfaces/configs';
+export declare class CheckoutProp65WarningComponent extends BaseComponent<null, ICheckoutComponent> {
+    constructor();
+    get hostClasses(): string[];
+    private colorMode;
+    protected template(): HTMLElement | HTMLElement[];
+}

package/dist/types/modules/checkout/components/checkout-send-as-gift.component.d.ts

@@ -3,5 +3,8 @@ import type { ICheckoutComponent } from '@/interfaces/configs';
 export declare class CheckoutSendAsGiftComponent extends BaseComponent<null, ICheckoutComponent> {
     get hostClasses(): string[];
     constructor();
+    private pendingToggleFocus;
+    protected afterRender(): void;
+    private readonly onToggle;
     protected template(): HTMLElement[];
 }

package/dist/types/modules/checkout/components/checkout-stripe-form.component.d.ts

@@ -1,3 +1,4 @@
+import { SafeHTMLElement } from '@/utils/dom-compat';
 declare global {
     interface Window {
         Stripe: any;
@@ -17,20 +18,25 @@ export interface IStripeConfig {
     elementOptions?: Record<string, any>;
 }
 export interface IStripeFormStatus {
+    selectedPaymentType?: string;
+    hasPendingConfirmation?: boolean;
     isFormComplete: boolean;
     isProcessing: boolean;
     hasCompletedPayment: boolean;
     hasError: boolean;
     errorMessage: string | null;
 }
-export declare class CheckoutStripeFormComponent extends HTMLElement {
+export declare class CheckoutStripeFormComponent extends SafeHTMLElement {
     private _initialized;
+    private _lifecycleGeneration;
     private _stripe;
     private _stripeElements;
     private _paymentElement;
     private _isProcessing;
+    private _selectedPaymentType;
     private _isFormComplete;
     private _hasUsedCurrentSession;
+    private _pendingConfirmation;
     private _stripeConfig;
     private _sessionRefreshPromise;
     initialize({ data }: {
@@ -44,11 +50,9 @@ export declare class CheckoutStripeFormComponent extends HTMLElement {
     private handleSubmit;
     private requestSessionRefresh;
     private refreshPaymentSession;
-    private resetForm;
     private updateStripeFormStatus;
     private createConfirmationTokenId;
     disconnected(): Promise<void>;
     disconnectedCallback(): void;
     private cleanupForm;
-    private loadStripeJS;
 }