@liquidcommerce/cloud-sdk 1.6.0 → 1.7.0

package/dist/types/interfaces/index.d.ts

@@ -3,6 +3,9 @@ export * from './cart.interface';
 export * from './catalog.interface';
 export * from './checkout.interface';
 export * from './liquid-commerce-client.interface';
+export * from './liquid-commerce-order-client.interface';
+export * from './order.interface';
 export * from './payment.interface';
+export * from './payment-element.interface';
 export * from './retailer.interface';
 export * from './user.interface';

package/dist/types/interfaces/liquid-commerce-client.interface.d.ts

@@ -1,10 +1,10 @@
-import type { IApiResponseWithData, IApiResponseWithoutData, ILiquidCommerceConfig } from '../types';
+import type { IApiResponseWithData, IApiResponseWithoutData, IAuth, ILiquidCommerceConfig } from '../types';
 import type { IAddressAutocompleteParams, IAddressAutocompleteResult, IAddressDetailsParams, IAddressDetailsResult } from './address.interface';
 import type { ICart, ICartUpdateParams } from './cart.interface';
 import type { IAvailabilityParams, IAvailabilityResponse, ICatalog, ICatalogParams } from './catalog.interface';
 import type { ICheckoutCompleteParams, ICheckoutCompleteResponse, ICheckoutPrepareParams, ICheckoutPrepareResponse } from './checkout.interface';
 import type { ILiquidPaymentConfig, ILiquidPaymentToken, IPaymentElementEventMap } from './payment.interface';
-import type { BaseUser, IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserPayment, IUserPaymentAddParams, IUserPaymentParams, IUserPaymentUpdateParams, IUserSessionParams } from './user.interface';
+import type { BaseUser, IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserPayment, IUserPaymentAddParams, IUserPaymentParams, IUserPaymentSession, IUserSession, IUserSessionParams } from './user.interface';
 /**
  * Interface representing the LiquidCommerce client.
  * Provides access to methods related to addresses, catalogs, carts, and initialization.
@@ -20,6 +20,14 @@ export interface ILiquidCommerceClient {
      * @throws {Error} - Throws an error if initialization fails.
      */
     init(): Promise<void>;
+    /**
+     * Authenticates a service, initiating the authentication process and providing an
+     * authorization response.
+     *
+     * @return {Promise<IAuth>} A promise that resolves to an authentication service
+     * response containing details of the authentication process.
+     */
+    auth(): Promise<IAuth>;
     /**
      * Provides methods for performing address autocompletion and retrieving address details.
      * See {@link IAddressMethod} for more details on the available methods.
@@ -321,6 +329,56 @@ export interface IUserMethod {
      * @see {@link IUser} for the structure of the user data returned.
      */
     session: (params: IUserSessionParams) => Promise<IApiResponseWithData<IUser>>;
+    /**
+     * Represents a payment session object used for the payment element mounting.
+     *
+     * @param {IUserPaymentSession} params - The parameters for creating a payment session.
+     * @returns {Promise<IApiResponseWithData<IUserSession>>} A Promise that resolves to the API response with user payment session.
+     *
+     * @example
+     * const liquidCommerce = await LiquidCommerce(apiKey, config);
+     *
+     * try {
+     *   const paymentSession = await liquidCommerce.user.paymentSession({
+     *     cartId: "6735340d5da29bac0eb78f7d",
+     *     customerEmail: "user@example.com"
+     *   });
+     *
+     *   console.log('User payment session:', paymentSession?.data);
+     * } catch (error) {
+     *   console.error('Failed to create user payment session:', error);
+     * }
+     *
+     * @throws {Error} - Throws an error if the sessions request fails or if authentication is unsuccessful.
+     *
+     * @see {@link IUserPaymentSession} for the structure of the payment session request parameters.
+     * @see {@link IUserSession} for the structure of the user data returned.
+     */
+    paymentSession: (params: IUserPaymentSession) => Promise<IApiResponseWithData<IUserSession>>;
+    /**
+     * Confirms a payment session using a token from the payment element.
+     *
+     * @param {string} token - The payment token received from the payment provider (e.g., Stripe) after user interaction.
+     * @returns {Promise<IApiResponseWithData<ILiquidPaymentToken>>} A Promise that resolves to the API response with the confirmed payment token details.
+     *
+     * @example
+     * const liquidCommerce = await LiquidCommerce(apiKey, config);
+     *
+     * try {
+     *   // Assume 'paymentElementToken' is obtained from the front-end after the user completes the payment steps.
+     *   const paymentElementToken = '1fa23fa4d5fad'; // Example token
+     *   const confirmedPayment = await liquidCommerce.user.confirmPaymentSession(paymentElementToken);
+     *
+     *   console.log('Confirmed payment session data:', confirmedPayment?.data);
+     * } catch (error) {
+     *   console.error('Failed to confirm payment session:', error);
+     * }
+     *
+     * @throws {Error} - Throws an error if the confirmation request fails or the token is invalid.
+     *
+     * @see {@link ILiquidPaymentToken} for the structure of the confirmed payment data returned.
+     */
+    confirmPaymentSession: (token: string) => Promise<IApiResponseWithData<ILiquidPaymentToken>>;
     /**
      * Represents a user object without creating a new session.
      *
@@ -484,7 +542,7 @@ export interface IUserMethod {
     /**
      * Updates a payment method for a user.
      *
-     * @param {IUserPaymentUpdateParams} params - The parameters for updating a payment method.
+     * @param {IUserPaymentParams} params - The parameters for updating a payment method.
      * @returns {Promise<IApiResponseWithData<IUserPayment>>} A promise that resolves to the API response with the updated payment method data.
      *
      * @example
@@ -507,7 +565,7 @@ export interface IUserMethod {
      * @see {@link IUserPaymentParams} for the structure of the update payment request parameters.
      * @see {@link IUserPayment} for the structure of the user's payment method data returned.
      */
-    updatePayment: (params: IUserPaymentParams | IUserPaymentUpdateParams) => Promise<IApiResponseWithData<boolean>>;
+    updatePayment: (params: IUserPaymentParams) => Promise<IApiResponseWithData<boolean>>;
     /**
      * Purges a payment method for a user.
      *
@@ -785,3 +843,24 @@ export interface ICheckoutMethod {
      */
     complete: (params: ICheckoutCompleteParams) => Promise<IApiResponseWithoutData<ICheckoutCompleteResponse>>;
 }
+export interface IWebhookMethod {
+    /**
+     * Retrieves whether the webhook test succeeded or not.
+     *
+     * @param {string} [endpoint] - The endpoint to test. If not provided, the default endpoint will be used.
+     * @returns {Promise<boolean>} A promise that resolves whether the test succeeded or not.
+     *
+     * @example
+     * const liquidCommerce = await LiquidCommerce(apiKey, config);
+     *
+     * try {
+     *   const testSucceeded = await liquidCommerce.webhook.test();
+     *   console.log('Webhook test succeeded:', testSucceeded);
+     * } catch (error) {
+     *   console.error('Failed to test Webhook:', error);
+     * }
+     *
+     * @throws {Error} Throws an error if the webhook test request fails or if authentication is unsuccessful.
+     */
+    test: (endpoint?: string) => Promise<boolean>;
+}

package/dist/types/interfaces/liquid-commerce-order-client.interface.d.ts

@@ -0,0 +1,54 @@
+import type { IApiResponseWithData, ILiquidCommerceOrderConfig } from '../types';
+import type { IOrder } from './order.interface';
+/**
+ * Interface representing the LiquidCommerce order client.
+ * Provides access to methods related to orders and initialization.
+ *
+ * @interface
+ */
+export interface ILiquidCommerceOrderClient {
+    /**
+     * Initializes the client by authenticating with the LiquidCommerce Order API.
+     * Should be called before making any API requests.
+     *
+     * @return {Promise<void>} - Resolves when the client is successfully initialized.
+     * @throws {Error} - Throws an error if initialization fails.
+     */
+    init(): Promise<void>;
+    /**
+     * Provides methods for order-related operations.
+     *
+     * @property {IOrderMethod} order - Object containing methods for order operations.
+     */
+    order: IOrderMethod;
+}
+/**
+ * Type for the LiquidCommerceOrderClient constructor.
+ * Used to define the expected constructor signature.
+ *
+ * @type {new (config: ILiquidCommerceOrderConfig) => ILiquidCommerceOrderClient} ILiquidCommerceOrderClientConstructor
+ */
+export type ILiquidCommerceOrderClientConstructor = new (config: ILiquidCommerceOrderConfig) => ILiquidCommerceOrderClient;
+export interface IOrderMethod {
+    /**
+     * Retrieves the order details based on the provided order ID.
+     *
+     * @param {string} identifier - The ID of the order to retrieve.
+     * @returns {Promise<IApiResponseWithData<IOrder>>} A promise that resolves to the API response with the order data.
+     *
+     * @example
+     * const orderLiquidCommerce = await OrderLiquidCommerce(apiKey, config);
+     *
+     * try {
+     *   const orderDetails = await orderLiquidCommerce.order.fetch('order_id_123');
+     *   console.log('Order details:', orderDetails.data);
+     * } catch (error) {
+     *   console.error('Failed to retrieve order details:', error);
+     * }
+     *
+     * @throws {Error} Throws an error if the order retrieval request fails or if authentication is unsuccessful.
+     *
+     * @see {@link IOrder} for the structure of the order data returned.
+     */
+    fetch: (identifier: string) => Promise<IApiResponseWithData<IOrder>>;
+}

package/dist/types/interfaces/order.interface.d.ts

@@ -0,0 +1,197 @@
+import type { ENUM_CUSTOMER_PLACEMENT, ENUM_ORDER_FULFILLMENT_TYPE, ENUM_ORDER_PACKAGE_STATUS, ENUM_ORDER_STATUS, ENUM_ORDER_SYSTEM } from 'enums';
+export interface IAddressCoordinates {
+    latitude: number | null;
+    longitude: number | null;
+}
+export interface IOrderAddress {
+    one: string;
+    two: string | null;
+    city: string;
+    state: string;
+    zip: string;
+    country: string;
+}
+export interface IOrderFullAddress extends IOrderAddress {
+    firstName: string | null;
+    lastName: string | null;
+    email: string;
+    phone: string | null;
+    company: string | null;
+}
+export interface IOrderFulfillmentTimeline {
+    status: ENUM_ORDER_STATUS;
+    timestamp: string;
+}
+export interface IOrderFulfillmentPackage {
+    id: string;
+    carrier: string | null;
+    trackingNumber: string | null;
+    trackingUrl: string | null;
+    status: ENUM_ORDER_PACKAGE_STATUS;
+    dateShipped: string | null;
+}
+export interface IOrderFulfillment {
+    id: string;
+    type: ENUM_ORDER_FULFILLMENT_TYPE;
+    status: ENUM_ORDER_STATUS;
+    scheduledFor: string | null;
+    updatedAt: string;
+    itemIds: string[];
+    packages: IOrderFulfillmentPackage[];
+    timeline: IOrderFulfillmentTimeline[];
+}
+export interface IOrderRetailerAddress extends IOrderAddress {
+    coordinates: IAddressCoordinates;
+}
+export interface IOrderRetailer {
+    id: string;
+    legacyId: string | null;
+    name: string;
+    system: ENUM_ORDER_SYSTEM;
+    timezone: string;
+    address: IOrderRetailerAddress;
+    amounts: IOrderAmounts;
+    fulfillments: IOrderFulfillment[];
+}
+export interface IOrderItemProductAttributes {
+    pack: boolean;
+    packDescription: string | null;
+    abv: string | null;
+    container: string | null;
+    containerType: string | null;
+}
+export interface IOrderItemProduct {
+    name: string;
+    brand: string;
+    upc: string;
+    sku: string;
+    mskus: string[];
+    category: string | null;
+    size: string | null;
+    volume: string | null;
+    uom: string | null;
+    proof: string | null;
+    attributes: IOrderItemProductAttributes;
+}
+export interface IOrderItemPricing {
+    price: number;
+    unitPrice: number;
+    quantity: number;
+    tax: number;
+    bottleDeposits: number;
+}
+export interface IOrderItemEngraving {
+    hasEngraving: boolean;
+    fee: number;
+    location: string | null;
+    lines: string[];
+}
+export interface IOrderItemGiftCard {
+    sender: string | null;
+    message: string | null;
+    recipients: string[];
+    sendDate: string | null;
+}
+export interface IOrderItemAttributes {
+    engraving: IOrderItemEngraving;
+    giftCard: IOrderItemGiftCard;
+}
+export interface IOrderItem {
+    id: string;
+    fulfillmentId: string | null;
+    retailerId: string;
+    variantId: string;
+    liquidId: string | null;
+    legacyGrouping: string | null;
+    legacyPid: string | null;
+    customerPlacement: ENUM_CUSTOMER_PLACEMENT;
+    product: IOrderItemProduct;
+    image: string | null;
+    pricing: IOrderItemPricing;
+    attributes: IOrderItemAttributes;
+    isPresale: boolean;
+    estimatedShipBy: string | null;
+}
+export interface IOrderCustomer {
+    id: string;
+    firstName: string | null;
+    lastName: string | null;
+    email: string;
+    phone: string | null;
+    birthdate: string | null;
+}
+export interface IOrderGiftRecipient {
+    name: string | null;
+    email: string | null;
+    phone: string | null;
+}
+export interface IOrderMarketingPreferences {
+    email: boolean;
+    sms: boolean;
+}
+export interface IOrderOptions {
+    isGift: boolean;
+    giftMessage: string | null;
+    giftRecipient: IOrderGiftRecipient;
+    hasVerifiedAge: boolean;
+    allowsSubstitution: boolean;
+    billingSameAsShipping: boolean;
+    deliveryInstructions: string | null;
+    marketingPreferences: IOrderMarketingPreferences;
+}
+export interface IOrderTaxDetails {
+    products: number;
+    shipping: number;
+    delivery: number;
+    bag: number;
+    bottleDeposits: number;
+    retailDelivery: number;
+}
+export interface IOrderDiscountDetails {
+    products: number;
+    shipping: number;
+    delivery: number;
+    engraving: number;
+    service: number;
+}
+export interface IOrderAmounts {
+    subtotal: number;
+    shipping: number;
+    platform: number;
+    tax: number;
+    engraving: number;
+    service: number;
+    delivery: number;
+    discounts: number;
+    giftCards: number;
+    tip: number;
+    total: number;
+    taxDetails: IOrderTaxDetails;
+    discountDetails: IOrderDiscountDetails;
+}
+export interface IOrderAddresses {
+    shipping: IOrderFullAddress;
+    billing: IOrderFullAddress;
+}
+export interface IOrderPaymentMethod {
+    type: string | null;
+    card: string | null;
+    last4: string | null;
+    holder: string | null;
+    code: string | null;
+}
+export interface IOrder {
+    referenceId: string | null;
+    legacyOrderNumber: string | null;
+    isHybrid: boolean;
+    partnerId: string;
+    createdAt: string;
+    updatedAt: string;
+    customer: IOrderCustomer;
+    addresses: IOrderAddresses;
+    options: IOrderOptions;
+    amounts: IOrderAmounts;
+    paymentMethods: IOrderPaymentMethod[];
+    retailers: IOrderRetailer[];
+    items: IOrderItem[];
+}

package/dist/types/interfaces/payment-element.interface.d.ts

@@ -0,0 +1,88 @@
+import type { IConfirmationTokenClientParams, IConfirmationTokenResponse, ILiquidPaymentElementOptions, IPaymentElementEventMap } from './payment.interface';
+import type { IUserSession } from './user.interface';
+export interface IPaymentElementConfig {
+    session: IUserSession;
+    elementId: string;
+    appearance?: {
+        theme?: 'stipe' | 'night' | 'flat';
+    };
+    elementOptions?: ILiquidPaymentElementOptions;
+}
+/**
+ * Defines the public interface for the Liquid Commerce Payment Element.
+ * This element provides a secure UI component for collecting payment information
+ * through an integrated payment provider.
+ *
+ * @interface ILiquidCommercePaymentElement
+ */
+export interface ILiquidCommercePaymentElement {
+    /**
+     * Mounts the payment UI component to the specified DOM element.
+     *
+     * @param {IPaymentElementConfig} config - Configuration for mounting the element,
+     * including the DOM element ID, appearance options, and session credentials.
+     * @returns {Promise<void>} A promise that resolves when the element is successfully mounted.
+     * @throws {Error} If the DOM element is not found, if the payment provider SDK fails to load,
+     * or if the component cannot be properly initialized.
+     */
+    mount(config: IPaymentElementConfig): Promise<void>;
+    /**
+     * Creates a secure confirmation token using the payment data collected by the UI component.
+     * This token can be used to complete the payment setup process on the server side.
+     *
+     * @param {IConfirmationTokenClientParams} [params] - Optional parameters for token creation,
+     * such as the return URL for redirect-based payment methods.
+     * @returns {Promise<IConfirmationTokenResponse>} A promise that resolves with
+     * an object containing the confirmation token ID on success, or an error object describing
+     * the failure reason (validation errors, network issues, etc.).
+     */
+    createConfirmationToken(params?: IConfirmationTokenClientParams): Promise<IConfirmationTokenResponse>;
+    /**
+     * Subscribes to events emitted by the payment UI component for real-time updates
+     * on user interactions and component state changes.
+     *
+     * @template K
+     * @param {K} eventType - The type of event to subscribe to. Supported events include:
+     * 'ready' (component fully loaded), 'change' (input changes), 'focus', 'blur',
+     * 'loaderror' (loading failures), and 'loaderstart' (loading initiated).
+     * @param {(event: IPaymentElementEventMap[K]) => void} handler - The callback function
+     * to execute when the specified event occurs. Receives event-specific data.
+     * @returns {void}
+     */
+    subscribe<K extends keyof IPaymentElementEventMap>(eventType: K, handler: (event: IPaymentElementEventMap[K]) => void): void;
+    /**
+     * Unsubscribes from events emitted by the payment UI component.
+     *
+     * @template K
+     * @param {K} eventType - The type of event to unsubscribe from.
+     * @param {(event: IPaymentElementEventMap[K]) => void} [handler] - The specific handler
+     * function to remove. If not provided, all handlers for the specified event type will be removed.
+     * @returns {void}
+     */
+    unsubscribe<K extends keyof IPaymentElementEventMap>(eventType: K, handler?: (event: IPaymentElementEventMap[K]) => void): void;
+    /**
+     * Unmounts the payment UI component from the DOM, removing its visual elements
+     * while preserving the internal state. The component can be remounted later.
+     * @returns {void}
+     */
+    unmount(): void;
+    /**
+     * Destroys the payment UI component, releasing all associated resources and clearing
+     * internal state. This is a permanent action - the component cannot be remounted
+     * after destruction and a new instance must be created if needed.
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Collapses the payment UI component to a minimized state if this feature is supported
+     * by the current configuration and payment provider.
+     * @returns {void}
+     */
+    collapse(): void;
+}
+/**
+ * @private
+ * Defines the constructor signature for the PaymentElementImpl class.
+ * Used internally by the singleton manager to instantiate the payment element.
+ */
+export type PaymentElementImplConstructor = new (options: IPaymentElementConfig) => ILiquidCommercePaymentElement;

package/dist/types/interfaces/payment.interface.d.ts

@@ -34,7 +34,7 @@ export interface ILiquidPaymentConfig {
     key: string;
     elementId: string;
     appearance?: {
-        theme?: 'default' | 'night' | 'flat';
+        theme?: 'stripe' | 'night' | 'flat';
     };
     elementOptions?: ILiquidPaymentElementOptions;
 }
@@ -126,6 +126,16 @@ export interface IPaymentElementEventMap {
         elementType: 'payment';
     };
 }
+/**
+ * Parameters for creating a Stripe Confirmation Token using the UI helper.
+ */
+export interface IConfirmationTokenClientParams {
+    returnUrl?: string;
+}
+export interface IConfirmationTokenPayload {
+    token: string;
+}
+export type IConfirmationTokenResponse = IConfirmationTokenPayload | ILiquidPaymentError;
 /**
  * Interface representing a payment provider that integrates with a Liquid payment gateway.
  */

package/dist/types/interfaces/retailer.interface.d.ts

@@ -69,11 +69,13 @@ export interface IRetailerFreeDelivery {
  *
  * @property {number} maxQuantity - The maximum quantity of items eligible for the shipping fee.
  * @property {number} fee - The fee amount for shipping.
+ * @property {number} min - The min item total required to checkout.
  * @property {boolean} active - Indicates whether the fee-based shipping configuration is active.
  */
 export interface IFeeShippingConfig {
     maxQuantity: number;
     fee: number;
+    min: number;
     active: boolean;
 }
 /**

package/dist/types/interfaces/user.interface.d.ts

@@ -1,5 +1,9 @@
 import type { ENUM_ADDRESS_TYPE } from '../enums';
 import type { ICoreParams } from '../types';
+export interface IUserSessionOb {
+    values?: [string, string[]];
+    createdAt: Date;
+}
 /**
  * Represents a user session with key and secret used for authentication.
  */
@@ -127,6 +131,15 @@ export interface IUserSessionParams extends ICoreParams {
     profileImage?: string | null;
     birthDate?: string | null;
 }
+/**
+ * Interface representing a user payment session.
+ */
+export interface IUserPaymentSession {
+    cartId?: string;
+    checkoutToken?: string;
+    customerId?: string;
+    customerEmail?: string;
+}
 /**
  * Interface representing the response from a purge operation.
  */
@@ -176,12 +189,3 @@ export interface IUserPaymentParams extends ICoreParams {
 export interface IUserPaymentAddParams extends IUserPaymentParams {
     isDefault?: boolean;
 }
-/**
- *
- * @deprecated - Use IUserPaymentParams
- *
- * @interface IUserPaymentParams
- */
-export interface IUserPaymentUpdateParams extends IUserPaymentParams {
-    isDefault: boolean;
-}

package/dist/types/liquid-commerce-order-client.d.ts

@@ -0,0 +1,19 @@
+import type { ILiquidCommerceOrderClient } from './interfaces';
+import type { ILiquidCommerceOrderConfig } from './types';
+/**
+ * Factory function to create and initialize a LiquidCommerceOrderClient instance.
+ *
+ * @param {ILiquidCommerceOrderConfig} config - The configuration object containing options such as environment settings, base URLs, and other preferences.
+ * @return {Promise<LiquidCommerceOrderClient>} - A promise that resolves to a fully initialized LiquidCommerceOrderClient instance.
+ *
+ * @example
+ * // Example usage:
+ * const orderLiquidClient = await LiquidCommerceOrders({
+ *   userID: 'yourUserID',
+ *   password: 'yourPassword',
+ *   env: LIQUID_COMMERCE_ENV.STAGE,
+ * });
+ *
+ * @throws {Error} - Throws an error if the client initialization fails.
+ */
+export declare function LiquidCommerceOrders(config: ILiquidCommerceOrderConfig): Promise<ILiquidCommerceOrderClient>;

package/dist/types/liquid-commerce-payment-element.d.ts

@@ -0,0 +1,10 @@
+import type { ILiquidCommercePaymentElement, IPaymentElementConfig } from './interfaces';
+/**
+ * Factory function to create a singleton payment element instance.
+ * Ensures consistent state management across the application.
+ *
+ * @param {IPaymentElementConfig} options - Configuration for the payment element.
+ * @returns {ILiquidCommercePaymentElement} Payment element instance.
+ * @throws {Error} If singleton manager is not properly configured.
+ */
+export declare function LiquidCommercePaymentElement(options: IPaymentElementConfig): ILiquidCommercePaymentElement;

package/dist/types/services/index.d.ts

@@ -1,5 +1,8 @@
 export * from './address.service';
+export * from './cart.service';
 export * from './catalog.service';
 export * from './checkout.service';
+export * from './order.service';
 export * from './payment.service';
 export * from './user.service';
+export * from './webhook.service';

package/dist/types/services/order.service.d.ts

@@ -0,0 +1,15 @@
+import type { OrderAuthenticatedService } from '../core';
+import type { IOrder } from '../interfaces';
+import type { IApiResponseWithData } from '../types';
+export declare class OrderService {
+    private client;
+    constructor(client: OrderAuthenticatedService);
+    /**
+     * Fetches an order by its identifier.
+     *
+     * @param {string} identifier - The identifier of the order to fetch.
+     * @returns {Promise<IApiResponseWithData<IOrder>>} A promise that resolves to the order data.
+     * @throws {Error} If the fetch request fails.
+     */
+    fetch(identifier: string): Promise<IApiResponseWithData<IOrder>>;
+}

package/dist/types/services/user.service.d.ts

@@ -1,13 +1,15 @@
-import type { AuthenticatedService } from '../core';
-import type { BaseUser, IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserPayment, IUserPaymentAddParams, IUserPaymentParams, IUserPaymentUpdateParams, IUserSessionParams } from '../interfaces';
+import type { AuthenticatedService, PaymentSessionHelperService } from '../core';
+import type { BaseUser, ILiquidPaymentToken, IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserPayment, IUserPaymentAddParams, IUserPaymentParams, IUserPaymentSession, IUserSession, IUserSessionParams } from '../interfaces';
 import type { IApiResponseWithData } from '../types';
 /**
  * A class representing a user service.
  */
 export declare class UserService {
     private client;
+    private paymentSessionHelperService;
     private readonly servicePath;
-    constructor(client: AuthenticatedService);
+    private readonly env;
+    constructor(client: AuthenticatedService, paymentSessionHelperService: PaymentSessionHelperService);
     /**
      * Creates or updates a user session.
      *
@@ -16,6 +18,22 @@ export declare class UserService {
      * @throws {Error} If the session creation/update request fails or if neither id nor email is provided.
      */
     createOrUpdateSession(params: IUserSessionParams): Promise<IApiResponseWithData<IUser>>;
+    /**
+     * Creates a payment session for a user.
+     *
+     * @param {IUserPaymentSession} params - The parameters required to create the payment session.
+     * @return {Promise<IApiResponseWithData<IUserSession>>} A promise that resolves to the API
+     *  response containing the user session data.
+     */
+    createPaymentSession(params: IUserPaymentSession): Promise<IApiResponseWithData<IUserSession>>;
+    /**
+     * Confirms and finalizes a payment session using the provided token.
+     *
+     * @param {string} token - The token representing the payment session to finalize.
+     * @return {Promise<IApiResponseWithData<ILiquidPaymentToken>>} A promise that resolves with the API
+     * response containing data about the finalized payment session.
+     */
+    finalizePaymentSession(token: string): Promise<IApiResponseWithData<ILiquidPaymentToken>>;
     /**
      * Fetches user data from the API using the provided identifier.
      *
@@ -113,7 +131,7 @@ export declare class UserService {
      *  the updated payment information.
      * @throws {Error} - Throws an error if required parameters are missing or the request fails.
      */
-    updatePayment(params: IUserPaymentParams | IUserPaymentUpdateParams): Promise<IApiResponseWithData<boolean>>;
+    updatePayment(params: IUserPaymentParams): Promise<IApiResponseWithData<boolean>>;
     /**
      * Purges a payment record for a specified customer.
      *