@liquidcommerce/cloud-sdk 1.0.1

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

@@ -0,0 +1,63 @@
+import type { DAYS_OF_WEEK, ENUM_MODALITIES } from '../enums';
+import type { IAddress } from './address.interface';
+export interface IRetailerTimes {
+    startsAt: string;
+    endsAt: string;
+}
+export interface IRetailerHoursConfig {
+    active: boolean;
+    times: IRetailerTimes[];
+}
+export type RetailerHours = {
+    [day in DAYS_OF_WEEK]: IRetailerHoursConfig;
+};
+export interface IRetailerExpectation {
+    detail: string;
+    short: string;
+}
+export interface IRetailerFreeDelivery {
+    min: number;
+    active: boolean;
+}
+export interface IFeeShippingConfig {
+    maxQuantity: number;
+    fee: number;
+    active: boolean;
+}
+export interface IRetailerFeeShipping {
+    individual: IFeeShippingConfig;
+    pack: IFeeShippingConfig;
+    free: IRetailerFreeDelivery;
+}
+export interface IRetailerFeeDelivery {
+    min: number;
+    fee: number;
+    free: IRetailerFreeDelivery;
+}
+export type IRetailerFees = IRetailerFeeShipping | IRetailerFeeDelivery;
+export interface IRetailerFulfillments {
+    id: string;
+    type: ENUM_MODALITIES;
+    deliveryFee?: number;
+    shippingFee?: number;
+    engravingFee?: number;
+    subtotal?: number;
+    timezone?: string;
+    fees: IRetailerFees;
+    expectation: IRetailerExpectation;
+    hours: RetailerHours;
+    breaks: IRetailerTimes[];
+    items: string[];
+}
+export interface IRetailer {
+    name: string;
+    id: string;
+    platformFee?: number;
+    deliveryFee?: number;
+    shippingFee?: number;
+    engravingFee?: number;
+    subtotal?: number;
+    total?: number;
+    address?: IAddress;
+    fulfillments: IRetailerFulfillments[];
+}

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

@@ -0,0 +1,53 @@
+import type { ENUM_ADDRESS_TYPE } from '../enums';
+import type { ICoreParams } from '../types';
+export interface IUserSession {
+    key: string | null;
+    secret: string | null;
+    createdAt: Date;
+}
+export interface IUserAddress {
+    id: string;
+    one: string;
+    two?: string | null;
+    city: string;
+    state: string;
+    zip: string;
+    country: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDefault?: boolean;
+}
+export interface IUser {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    phone: string | null;
+    birthDate: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    addresses: IUserAddress[];
+    session: IUserSession;
+}
+export interface IUserSessionParams extends ICoreParams {
+    id?: string;
+    email?: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    phone?: string | null;
+    birthDate?: string | null;
+}
+export interface IPurgeResponse {
+    deleted: boolean;
+    message: string;
+}
+export interface IUserAddressParams extends ICoreParams {
+    customerId: string;
+    one: string;
+    two?: string | null;
+    city: string;
+    state: string;
+    zip: string;
+    isDefault?: boolean;
+    type: ENUM_ADDRESS_TYPE;
+}

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

@@ -0,0 +1,189 @@
+import { LIQUID_COMMERCE_ENV } from './enums';
+import type { ICart, ICartUpdateParams } from './interfaces/cart.interface';
+import type { ICatalog, ICatalogParams } from './interfaces/catalog.service.interface';
+import type { ICheckoutCompleteParams, ICheckoutCompleteResponse, ICheckoutPrepareParams, ICheckoutPrepareResponse } from './interfaces/checkout.interface';
+import type { IAddressMethod, ICartMethod, ICatalogMethod, ICheckoutMethod, ILiquidCommerceClient, IPaymentMethod, IUserMethod } from './interfaces/liquid-commerce-client.interface';
+import type { ILiquidPaymentConfig, ILiquidPaymentToken, IPaymentElementEventMap } from './interfaces/payment.interface';
+import type { IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserSessionParams } from './interfaces/user.interface';
+import type { IAddressAutocompleteParams, IAddressAutocompleteResult, IAddressDetailsParams, IAddressDetailsResult } from './services/address.service';
+import type { IAvailabilityParams, IAvailabilityResponse } from './services/catalog.service';
+import type { IApiResponseWithData, IApiResponseWithoutData, ILiquidCommerceConfig } from './types';
+/**
+ * The LiquidCommerceClient class is a client for interacting with the LiquidCommerce Cloud APIs.
+ * This client encapsulates the logic for working with various services, including addresses, catalog products,
+ * carts, users, payments, checkouts, and orders.
+ *
+ * The client handles authentication, service initialization, and ensures secure interaction with the
+ * LiquidCommerce Cloud API by managing token expiration and re-authentication automatically.
+ *
+ * @class
+ * @implements {ILiquidCommerceClient}
+ */
+declare class LiquidCommerceClient implements ILiquidCommerceClient {
+    private readonly authenticatedClient;
+    private addressService;
+    private catalogService;
+    private cartService;
+    private userService;
+    private paymentService;
+    private checkoutService;
+    private config;
+    private singletonManager;
+    /**
+     * Creates an instance of LiquidCommerceClient.
+     *
+     * @constructor
+     * @param {string} apiKey - The API key used for authenticating with the LiquidCommerce Cloud API.
+     * @param {ILiquidCommerceConfig} config - Configuration options including environment settings, base URLs, and other preferences.
+     */
+    constructor(apiKey: string, config: ILiquidCommerceConfig);
+    /**
+     * Determines the appropriate base URL for the API based on the environment.
+     *
+     * @private
+     * @param {ILiquidCommerceConfig} config - Configuration options.
+     * @return {string} - The base URL for the selected environment.
+     */
+    private determineBaseURL;
+    /**
+     * Initializes the client by authenticating with the LiquidCommerce API.
+     * This method should be called before making any API requests.
+     *
+     * @public
+     * @return {Promise<void>} - Resolves when initialization is successful.
+     * @throws {Error} - Throws an error if authentication fails.
+     */
+    init(): Promise<void>;
+    /**
+     * Ensures that the client is authenticated before making API requests.
+     * If the authentication token is expired, it will attempt to re-authenticate.
+     *
+     * @private
+     * @return {Promise<void>} - Resolves when the client is authenticated.
+     * @throws {Error} - Throws an error if re-authentication fails.
+     */
+    private ensureAuthenticated;
+    /**
+     * Address object that provides methods for performing address autocompletion and retrieving address details.
+     *
+     * @interface IAddressMethod address
+     *
+     * @property {function(Omit<IAddressAutocompleteParams, 'key'>): Promise<IApiResponseWithData<IAddressAutocompleteResult[]>>} autocomplete -
+     *    Method for performing address autocompletion based on the provided parameters.
+     *
+     * @property {function(Omit<IAddressDetailsParams, 'key'>): Promise<IApiResponseWithData<IAddressDetailsResult>>} details -
+     *    Method for retrieving address details based on the provided parameters.
+     */
+    address: IAddressMethod;
+    /**
+     * Catalog object that provides methods for availability and search operations.
+     *
+     * @interface ICatalogMethod catalog
+     *
+     * @property {function(params: IAvailabilityParams): Promise<IApiResponseWithoutData<IAvailabilityResponse>>} availability -
+     *    Method to check the availability of a specific item in the catalog.
+     *
+     * @property {function(params: ICatalogParams): Promise<IApiResponseWithoutData<ICatalog>>} search -
+     *    Method to perform a search in the catalog based on the provided parameters.
+     *
+     * @see {@link IApiResponseWithoutData} for the structure of the promise returned by both methods.
+     */
+    catalog: ICatalogMethod;
+    /**
+     * Represents a cart object with methods for updating and retrieving cart data.
+     *
+     * @interface ICartMethod cart
+     *
+     * @property {function(id: string): Promise<IApiResponseWithoutData<ICart>>} get -
+     *    Retrieves the cart by its ID, or returns a new cart if no ID is provided.
+     * @property {function(params: ICartUpdateParams): Promise<IApiResponseWithoutData<ICart>>} update -
+     *    Method to update the cart with the provided parameters.
+     *
+     * @see {@link ICartUpdateParams} for the structure of the parameters required to update the cart.
+     * @see {@link IApiResponseWithoutData} for the structure of the promise returned by both methods.
+     * @see {@link ICart} for the structure of the cart data returned.
+     */
+    cart: ICartMethod;
+    /**
+     * User object that provides methods for user-related operations.
+     *
+     * @interface IUserMethod user
+     *
+     * @property {function(params: IUserSessionParams): Promise<IApiResponseWithData<IUser>>} session -
+     *    Method for creating or updating a user session.
+     * @property {function(identifier: string): Promise<IApiResponseWithData<IPurgeResponse>>} purge -
+     *    Method for purging a user's data from the system.
+     * @property {function(params: IUserAddressParams): Promise<IApiResponseWithData<IUserAddress>>} updateAddress -
+     *    Method for updating or creating a user's address.
+     * @property {function(addressId: string): Promise<IApiResponseWithData<IPurgeResponse>>} purgeAddress -
+     *    Method for purging a user's address.
+     *
+     * @see {@link IUserSessionParams} for the structure of the session request parameters.
+     * @see {@link IUserAddressParams} for the structure of the address update request parameters.
+     * @see {@link IUser} for the structure of the user data returned.
+     * @see {@link IUserAddress} for the structure of the user's address data returned.
+     * @see {@link IPurgeResponse} for the structure of the user data returned.
+     *
+     * */
+    user: IUserMethod;
+    /**
+     * Payment object that provides methods for payment-related operations.
+     *
+     * @interface IPaymentMethod payment
+     *
+     * @property {function(config: ILiquidPaymentConfig): Promise<void>} mount -
+     *    Method for mounting the payment element into the DOM.
+     *
+     * @property {function(): Promise<ILiquidPaymentToken>} generateToken -
+     *    Method for generating a payment token for the current payment information.
+     *
+     * @property {function(eventType: K, handler: function): void} subscribe -
+     *    Method for subscribing to payment element events.
+     *
+     * @property {function(eventType: K, handler?: function): void} unsubscribe -
+     *    Method for unsubscribing from payment element events.
+     *
+     * @see {@link ILiquidPaymentConfig} Represents the configuration for Liquid payment.
+     * @see {@link ILiquidPaymentToken} Represents a payment token for liquid payments.
+     * @see {@link ILiquidPaymentError} Represents an error that occurs during a liquid payment.
+     * @see {@link ILiquidPaymentElementOptions} The options for the payment element.
+     * @see {@link IPaymentElementEventMap} The map of payment element event types to their corresponding event objects.
+     */
+    payment: IPaymentMethod;
+    /**
+     * Checkout object that provides methods for checkout-related operations.
+     *
+     * @interface ICheckoutMethod checkout
+     *
+     * @property {function(params: ICheckoutPrepareParams): Promise<IApiResponseWithoutData<ICheckoutPrepareResponse>>} prepare -
+     *    Method to prepare a checkout based on the provided parameters.
+     * @property {function(params: ICheckoutCompleteParams): Promise<IApiResponseWithoutData<ICheckoutCompleteResponse>>} complete -
+     *   Method completes a checkout process with the provided token and payment information.
+     *
+     * @see {@link ICheckoutPrepareParams} for the structure of the prepare request parameters.
+     * @see {@link IApiResponseWithoutData} for the structure of the promise returned by the prepare method.
+     * @see {@link ICheckoutPrepareResponse} for the structure of the prepared checkout data returned.
+     * @see {@link ICheckoutCompleteParams} for the structure of the complete request parameters.
+     * @see {@link ICheckoutCompleteResponse} for the structure of the complete checkout data returned.
+     */
+    checkout: ICheckoutMethod;
+}
+/**
+ * Factory function to create and initialize a LiquidCommerceClient instance.
+ *
+ * @param {string} apiKey - The API key used for authenticating with the Liquid Commerce Cloud API.
+ * @param {ILiquidCommerceConfig} config - The configuration object containing options such as environment settings, base URLs, and other preferences.
+ * @return {Promise<LiquidCommerceClient>} - A promise that resolves to a fully initialized LiquidCommerceClient instance.
+ *
+ * @example
+ * // Example usage:
+ * const liquidClient = await LiquidCommerce('your-api-key', {
+ *   env: LIQUID_COMMERCE_ENV.STAGE,
+ *   googlePlacesApiKey: 'your-google-places-api-key',
+ * });
+ *
+ * @throws {Error} - Throws an error if the client initialization fails.
+ */
+export declare function LiquidCommerce(apiKey: string, config: ILiquidCommerceConfig): Promise<LiquidCommerceClient>;
+export { LIQUID_COMMERCE_ENV };
+export type { IAddressAutocompleteParams, IAddressAutocompleteResult, IAddressDetailsParams, IAddressDetailsResult, IAddressMethod, IApiResponseWithData, IApiResponseWithoutData, IAvailabilityParams, IAvailabilityResponse, ICart, ICartMethod, ICartUpdateParams, ICatalog, ICatalogMethod, ICatalogParams, ICheckoutCompleteParams, ICheckoutCompleteResponse, ICheckoutMethod, ICheckoutPrepareParams, ICheckoutPrepareResponse, ILiquidCommerceClient, ILiquidCommerceConfig, ILiquidPaymentConfig, ILiquidPaymentToken, IPaymentElementEventMap, IPaymentMethod, IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserMethod, IUserSessionParams, };

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

@@ -0,0 +1,44 @@
+import type { AuthenticatedService } from '../core';
+import type { ICoords } from '../interfaces/address.interface';
+import type { IApiResponseWithData, ICoreParams } from '../types';
+export interface IAddressAutocompleteParams extends ICoreParams {
+    input: string;
+}
+export interface IAddressAutocompleteResult {
+    id: string;
+    description: string;
+}
+export interface IAddressDetailsParams extends ICoreParams {
+    id: string;
+}
+export interface IAddressDetailsResult {
+    formattedAddress: string;
+    coords: ICoords;
+}
+type AddressServiceResponse<T> = IApiResponseWithData<T>;
+/**
+ * Represents a service for interacting with address-related functionality.
+ */
+export declare class AddressService {
+    private client;
+    constructor(client: AuthenticatedService);
+    /**
+     * Performs autocomplete on an address using the Google Places API.
+     * @param {IAddressAutocompleteParams} params - The parameters for the autocomplete request.
+     * @param {string} googlePlacesApiKey - The API key for accessing the Google Places API.
+     * @return {Promise<AddressServiceResponse<IAddressAutocompleteResult[]>>} - A Promise that resolves to the autocomplete response.
+     * @throws {Error} - If the autocomplete request fails.
+     */
+    autocomplete(params: IAddressAutocompleteParams, googlePlacesApiKey: string): Promise<AddressServiceResponse<IAddressAutocompleteResult[]>>;
+    /**
+     * Retrieves detailed information about an address using Google Places API.
+     *
+     * @async
+     * @param {IAddressDetailsParams} params - The parameters for retrieving address details.
+     * @param {string} googlePlacesApiKey - The API key for accessing Google Places API.
+     * @return {Promise<AddressServiceResponse<IAddressDetailsResult>>} A promise that resolves to the response containing the detailed information about an address.
+     * @throws {Error} if the request to retrieve address details fails.
+     */
+    details(params: IAddressDetailsParams, googlePlacesApiKey: string): Promise<AddressServiceResponse<IAddressDetailsResult>>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import type { AuthenticatedService, CartHelperService } from '../core';
+import type { ICart, ICartUpdateParams } from '../interfaces/cart.interface';
+import type { IApiResponseWithoutData } from '../types';
+/**
+ * The CartService class is responsible for fetching and updating cart data from the server.
+ *
+ * @class CartService
+ */
+export declare class CartService {
+    private client;
+    private cartHelperService;
+    private readonly servicePath;
+    constructor(client: AuthenticatedService, cartHelperService: CartHelperService);
+    /**
+     * Retrieves the cart with the specified ID or a new cart from the server.
+     *
+     * @param {string} id - The ID of the cart to retrieve.
+     * @param {boolean} refresh - A flag that if true return a refreshed access token.
+     * @return {Promise<IApiResponseWithoutData<ICart>>} A Promise that resolves to the cart object.
+     * @throws {Error} If the request to update the cart fails.
+     */
+    get(id?: string, refresh?: boolean): Promise<IApiResponseWithoutData<ICart>>;
+    /**
+     * Updates the cart with the provided parameters.
+     *
+     * @param {ICartUpdateParams} params - The parameters for updating the cart.
+     * @returns {Promise<IApiResponseWithoutData<ICart>>} A promise that resolves to the updated cart data.
+     * @throws {Error} If the cart update request fails.
+     */
+    update(params: ICartUpdateParams): Promise<IApiResponseWithoutData<ICart>>;
+}

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

@@ -0,0 +1,38 @@
+import type { AuthenticatedService, CatalogHelperService } from '../core';
+import type { ILocBase } from '../interfaces/address.interface';
+import type { IProduct } from '../interfaces/catalog.interface';
+import type { ICatalog, ICatalogParams } from '../interfaces/catalog.service.interface';
+import type { IRetailer } from '../interfaces/retailer.interface';
+import type { IApiResponseWithoutData } from '../types';
+export interface IAvailabilityParams extends ILocBase {
+    upcs: string[];
+    shouldShowOffHours?: boolean;
+}
+export interface IAvailabilityResponse {
+    products: IProduct[];
+    retailers: IRetailer[];
+}
+/**
+ * The CatalogService class provides methods for interacting with the catalog API.
+ */
+export declare class CatalogService {
+    private client;
+    private catalogHelperService;
+    private readonly servicePath;
+    constructor(client: AuthenticatedService, catalogHelperService: CatalogHelperService);
+    /**
+     * Makes an asynchronous request to check the availability of a specific item in the catalog.
+     * @param {IAvailabilityParams} params - The parameters for the availability request.
+     * @return {Promise<IApiResponseWithoutData<IAvailabilityResponse>>} - A Promise that resolves to an API response object without data, containing availability information.
+     * @throws {Error} - If the availability request fails, an error is thrown.
+     */
+    availability(params: IAvailabilityParams): Promise<IApiResponseWithoutData<IAvailabilityResponse>>;
+    /**
+     * Performs a search in the catalog based on the provided parameters.
+     *
+     * @param {ICatalogParams} params - The search parameters.
+     * @return {Promise<IApiResponseWithoutData<ICatalog>>} - A promise that resolves to the catalog search response.
+     * @throws {Error} - If the search parameters are invalid or if the search request fails.
+     */
+    search(params: ICatalogParams): Promise<IApiResponseWithoutData<ICatalog>>;
+}

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

@@ -0,0 +1,28 @@
+import type { AuthenticatedService, CheckoutHelperService } from '../core';
+import type { ICheckoutCompleteParams, ICheckoutCompleteResponse, ICheckoutPrepareParams, ICheckoutPrepareResponse } from '../interfaces/checkout.interface';
+import type { IApiResponseWithoutData } from '../types';
+/**
+ * A service for managing the checkout process.
+ */
+export declare class CheckoutService {
+    private client;
+    private checkoutHelperService;
+    private readonly servicePath;
+    constructor(client: AuthenticatedService, checkoutHelperService: CheckoutHelperService);
+    /**
+     * Prepares a checkout based on the provided parameters.
+     *
+     * @param {ICheckoutPrepareParams} params - The parameters for preparing the checkout.
+     * @returns {Promise<IApiResponseWithoutData<ICheckoutPrepareResponse>>} A promise that resolves to the prepared checkout data.
+     * @throws {Error} If the checkout preparation request fails.
+     */
+    prepare(params: ICheckoutPrepareParams): Promise<IApiResponseWithoutData<ICheckoutPrepareResponse>>;
+    /**
+     * Completes the checkout process.
+     *
+     * @param params - The parameters required to complete the checkout.
+     * @returns A promise that resolves to the API response without data for the completed checkout.
+     * @throws Throws an error if the checkout complete request fails.
+     */
+    complete(params: ICheckoutCompleteParams): Promise<IApiResponseWithoutData<ICheckoutCompleteResponse>>;
+}

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

@@ -0,0 +1,39 @@
+import type { PaymentProviderService } from '../core';
+import type { ILiquidPaymentConfig, ILiquidPaymentError, ILiquidPaymentToken, IPaymentElementEventMap } from '../interfaces/payment.interface';
+/**
+ * The PaymentService class provides methods for interacting with payment functionality.
+ */
+export declare class PaymentService {
+    private paymentProvider;
+    constructor(paymentProvider: PaymentProviderService);
+    /**
+     * Injects a payment element using the provided configuration.
+     *
+     * @param config - The configuration object to be used for injecting the payment element.
+     * @returns A Promise that resolves when the payment element has been successfully injected.
+     * @throws If a failure occurs while injecting the payment element.
+     */
+    mount(config: ILiquidPaymentConfig): Promise<void>;
+    /**
+     * Generates a payment token.
+     *
+     * @return {Promise<ILiquidPaymentToken | ILiquidPaymentError>} - A promise that resolves to either a payment token or an error.
+     */
+    generateToken(): Promise<ILiquidPaymentToken | ILiquidPaymentError>;
+    /**
+     * Subscribes a handler function to a specific event type in the payment element.
+     *
+     * @param eventType - The type of event to subscribe to. Must be one of the keys in IPaymentElementEventMap.
+     * @param handler - The handler function to be called when the specified event occurs.
+     * @return void
+     */
+    subscribe<K extends keyof IPaymentElementEventMap>(eventType: K, handler: (event: IPaymentElementEventMap[K]) => void): void;
+    /**
+     * Unsubscribes a handler function from a specific event type for the payment element.
+     *
+     * @param eventType - The event type to unsubscribe from.
+     * @param handler - Optional. The handler function to unsubscribe. If provided, only the specific handler will be unsubscribed. If not provided, all handlers for the event type will be unsubscribed.
+     * @return void
+     */
+    unsubscribe<K extends keyof IPaymentElementEventMap>(eventType: K, handler?: (event: IPaymentElementEventMap[K]) => void): void;
+}

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

@@ -0,0 +1,43 @@
+import type { AuthenticatedService } from '../core';
+import type { IPurgeResponse, IUser, IUserAddress, IUserAddressParams, IUserSessionParams } from '../interfaces/user.interface';
+import type { IApiResponseWithData } from '../types';
+/**
+ * A class representing a user service.
+ */
+export declare class UserService {
+    private client;
+    private readonly servicePath;
+    constructor(client: AuthenticatedService);
+    /**
+     * Creates or updates a user session.
+     *
+     * @param {IUserSessionParams} params - The parameters for creating or updating a user session.
+     * @returns {Promise<IApiResponseWithData<IUser>>} A promise that resolves to the user data.
+     * @throws {Error} If the session creation/update request fails or if neither id nor email is provided.
+     */
+    createOrUpdateSession(params: IUserSessionParams): Promise<IApiResponseWithData<IUser>>;
+    /**
+     * Purges a user's data from the system.
+     *
+     * @param {string} identifier - The user's ID or email.
+     * @returns {Promise<IApiResponseWithData<IPurgeResponse>>} A promise that resolves to the purge response.
+     * @throws {Error} If the purge request fails or if the identifier is not provided.
+     */
+    purge(identifier: string): Promise<IApiResponseWithData<IPurgeResponse>>;
+    /**
+     * Updates or creates a new address for a user.
+     *
+     * @param {IUserAddressParams} params - The parameters for updating or creating an address.
+     * @returns {Promise<IApiResponseWithData<IUserAddress>>} A promise that resolves to the updated or created address.
+     * @throws {Error} If the address update request fails or if required parameters are missing.
+     */
+    updateAddress(params: IUserAddressParams): Promise<IApiResponseWithData<IUserAddress>>;
+    /**
+     * Purges an address for a user.
+     *
+     * @param {string} addressId - The ID of the address to purge.
+     * @returns {Promise<IApiResponseWithData<IPurgeResponse>>} A promise that resolves to the purge response.
+     * @throws {Error} If the address purge request fails or if the address ID is not provided.
+     */
+    purgeAddress(addressId: string): Promise<IApiResponseWithData<IPurgeResponse>>;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,36 @@
+import type { ENUM_BEER, ENUM_FOOD, ENUM_MERCHANDISE, ENUM_NON_ALCOHOLIC, ENUM_READY_TO_DRINK, ENUM_SPIRITS, ENUM_WINE, LIQUID_COMMERCE_ENV } from './enums';
+export interface ICoreParams {
+    refresh?: boolean;
+}
+export interface IAuthResponse {
+    auth?: IAuthResponse;
+}
+export interface IResponseMetadata {
+    languages: string[];
+    timestamp: number;
+    timezone: string;
+    requestId: string;
+    path: string;
+    version: string;
+}
+export interface IApiResponseBase extends IAuthResponse {
+    statusCode: number;
+    message: string;
+    metadata: IResponseMetadata;
+}
+export type IApiResponseWithData<T> = IApiResponseBase & {
+    data: T;
+};
+export type IApiResponseWithoutData<T> = IApiResponseBase & {
+    [K in keyof T]: T[K];
+};
+export type IApiResponse<T> = IApiResponseWithData<T> | IApiResponseWithoutData<T>;
+export declare function isApiResponseWithData<T>(response: IApiResponse<T>): response is IApiResponseWithData<T>;
+export interface ILiquidCommerceConfig {
+    googlePlacesApiKey: string;
+    env: LIQUID_COMMERCE_ENV;
+    baseUrl?: {
+        stage?: string;
+    };
+}
+export type LiquidTaxonomy = ENUM_BEER | ENUM_FOOD | ENUM_MERCHANDISE | ENUM_NON_ALCOHOLIC | ENUM_READY_TO_DRINK | ENUM_SPIRITS | ENUM_WINE;