@billgangcom/theme-lib 1.110.4 → 1.110.5

package/dist/src/storefront/models/shop.d.ts

@@ -0,0 +1,38 @@
+export type Image = {
+    id: number;
+    cfId: string;
+};
+export interface ShopInfo {
+    statistics: {
+        totalProductsSold: number;
+        totalCustomers: number;
+        totalReviews: number;
+        averageProductRating: number;
+        launchYear: number;
+    };
+    permissions: {
+        disableBranding: boolean;
+    };
+    info: {
+        logo?: Image;
+        id: string;
+        name: string;
+        domain: string;
+        passwordProtected: boolean;
+        onHold: boolean;
+        isBanned: boolean;
+    };
+    isPasswordValid: boolean;
+}
+export interface ShopRefundPolicy {
+    refundPolicy: string;
+    showRefundPolicyOnProduct: boolean;
+}
+export interface ShopPrivacyPolicy {
+    privacyPolicy: string;
+    showPrivacyPolicyOnProduct: boolean;
+}
+export interface ShopTerms {
+    termsOfService: string;
+    showTermsOfServiceOnProduct: boolean;
+}

package/dist/src/storefront/models/subscription.d.ts

@@ -0,0 +1,130 @@
+import { PartOrder } from './order';
+import { Price } from './price';
+export type PostSubscriptionRequest = {
+    customerEmail: string;
+    gateway: string;
+    partOrder: PartOrder;
+    recaptcha: string;
+    coupon?: string | null;
+    customFields: Record<string, string>;
+    discordSocialConnectId?: string | null;
+    referralCode?: string | null;
+    tsId: string | null;
+};
+export declare enum SubscriptionStatus {
+    RIAL = "RIAL",
+    AWAITING_PAYMENT = "AWAITING_PAYMENT",
+    ACTIVE = "ACTIVE",
+    PAST_DUE = "PAST_DUE",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED",
+    CHANGED_GATEWAY = "CHANGED_GATEWAY",
+    REPLACED = "REPLACED"
+}
+export interface SubscriptionItem {
+    id: string;
+    productName: string;
+    status: SubscriptionStatus;
+    price: Price;
+    gatewayName: string;
+    createdAt: string;
+    accessToken: string;
+    recurringInterval: string;
+    currentChargeAttempt: number;
+    nextChargeAttemptAt?: string;
+    activeTo?: string;
+}
+export interface SubscriptionCoupon {
+    isFixed: boolean;
+    discount: number;
+    name: string;
+    initialCouponDurationForSubscriptions?: number;
+    currentCouponDurationForSubscriptions?: number;
+}
+interface SubscriptionSettings {
+    price: Price;
+    recurringIntervalDays: number;
+}
+interface CustomField {
+    name: string;
+    required: boolean;
+    placeholder: string;
+    defaultValue: string;
+    regex: string;
+    type: string;
+}
+interface ProductVariantData {
+    id: number;
+    name: string;
+    description?: string;
+    shortDescription?: string;
+    price: Price;
+    chargeTypes: string[];
+    subscriptionSettings: SubscriptionSettings;
+    quantity: {
+        restrictions: any;
+    };
+    deliveryTime: number;
+    gateways: {
+        name: string;
+    }[];
+    customFields: CustomField[];
+    warranty?: {
+        text: string;
+        durationMilliseconds: number;
+    };
+    discordSettings: {
+        isEnabled: boolean;
+        isRequired: boolean;
+    };
+}
+interface Type {
+    id: string;
+    name: string;
+    productVariants: {
+        data: ProductVariantData;
+        position: number;
+        isHighlighted: boolean;
+    }[];
+    position: number;
+}
+interface SubscriptionUpgradePlansData {
+    id: string;
+    name: string;
+    description: string;
+    types: Type[];
+}
+export interface SubscriptionUpgradePlans {
+    data: SubscriptionUpgradePlansData;
+}
+export interface SubscriptionGatewayInfo {
+    card?: {
+        brand: string;
+        last4: string;
+        expires: string;
+    };
+}
+export interface SubscriptionFullItem {
+    id: string;
+    productName: string;
+    status: SubscriptionStatus;
+    price: Price;
+    gatewayName: string;
+    createdAt: string;
+    accessToken: string;
+    recurringInterval: string;
+    currentChargeAttempt: number;
+    nextChargeAttemptAt?: string;
+    activeTo?: string;
+    productDescription?: string;
+    productImage?: {
+        id: number;
+        cfId: string;
+    };
+    availableGateways: string[];
+    gatewayInfo?: SubscriptionGatewayInfo;
+    coupon?: SubscriptionCoupon;
+    variantId: number;
+    pricingPlanExists: boolean;
+}
+export {};

package/dist/src/storefront/models/transaction.d.ts

@@ -0,0 +1,12 @@
+import { Price } from './price';
+export declare enum TransactionStatus {
+    ADDED = "ADDED",
+    REMOVED = "REMOVED"
+}
+export interface Transaction {
+    id: string;
+    price: Price;
+    createdAt: string;
+    description: string;
+    status: TransactionStatus;
+}

package/dist/src/storefront/store/index.d.ts

@@ -0,0 +1,22 @@
+export * from './useCustomerDashboardStore';
+export * from './useStorefrontStore';
+export * from './useCartStore';
+export * from './usePaginationPagesStore';
+export * from './useDiscordStore';
+export * from './useSubscriptionStore';
+export * from './useApiStore';
+export * from './useBlocksStore';
+export * from './useGeneralStore';
+export * from './useSettingsStore';
+export * from './useThemeSettingsStore';
+export * from './useNotificationStore';
+export * from './useModalStore';
+export * from './usePagesStore';
+export * from './useShareLinkStore';
+export * from './useLayersStore';
+export * from './useHistoryState';
+export * from './usePreviewStore';
+export * from './useNavbarStore';
+export * from './useChooseImageStore';
+export * from './useErrorStore';
+export * from './useConfirmationModalStore';

package/dist/src/storefront/store/useApiStore.d.ts

@@ -0,0 +1,8 @@
+type API_URLS_KEYS = 'api' | 'googleFonts' | 'storeApi' | 'slApi' | 'customersApi' | 'cashappApi';
+export type ApiUrls = Record<API_URLS_KEYS, string>;
+interface Options {
+    apiUrls: ApiUrls;
+    setApiUrls: (apiUrls: ApiUrls) => void;
+}
+export declare const useApiStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useBlocksStore.d.ts

@@ -0,0 +1,23 @@
+import { Block } from '@constants';
+interface Options {
+    header: any;
+    footer: any;
+    announcement: any;
+    setHeader: (header: any) => void;
+    setFooter: (footer: any) => void;
+    setAnnouncement: (announcement: any) => void;
+    blocks: Block | null;
+    setBlocks: (blocks: Block | null) => void;
+    activeBlock: string | null;
+    setActiveBlock: (activeBlock: string | null) => void;
+    sourceBlocks: Block;
+    setSourceBlocks: (sourceBlocks: Block) => void;
+    currentInstance: any;
+    setCurrentInstance: (currentInstance: any) => void;
+    settings: any;
+    setSettings: (settings: any) => void;
+    settingsInstance: any;
+    setSettingsInstance: (settingsInstance: any) => void;
+}
+export declare const useBlocksStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useCartStore.d.ts

@@ -0,0 +1,48 @@
+import type { OrderRequest } from '@storefront/models';
+import { Product } from '../../abstractions';
+export type ValidateCouponApiData = {
+    restrictToProductIds?: number[];
+    isFixed?: boolean;
+    discount?: number;
+};
+export type Cart = OrderRequest & {
+    paymentMethod: string;
+};
+interface Options {
+    cart: Cart;
+    products: Product[];
+    coupon: ValidateCouponApiData | null;
+    pending: boolean;
+    applyCouponPending: boolean;
+    customerEmail: string | null;
+    recaptcha: string;
+    priceAdjustment: {
+        fixedAmount: number;
+        isDiscount: boolean;
+        percentage: number;
+    } | null;
+    serviceFee: {
+        fixedAmount: number;
+        isDiscount: boolean;
+        percentage: number;
+    } | null;
+    setCart: (updater: Cart | ((prev: Cart) => Cart)) => void;
+    setProducts: (updater: Product[] | ((prev: Product[]) => Product[])) => void;
+    setCoupon: (coupon: ValidateCouponApiData | null) => void;
+    setPending: (pending: boolean) => void;
+    setApplyCouponPending: (pending: boolean) => void;
+    setRecaptcha: (recaptcha: string) => void;
+    setCustomerEmail: (customerEmail: string) => void;
+    setPriceAdjustment: (value: {
+        fixedAmount: number;
+        isDiscount: boolean;
+        percentage: number;
+    } | null) => void;
+    setServiceFee: (value: {
+        fixedAmount: number;
+        isDiscount: boolean;
+        percentage: number;
+    } | null) => void;
+}
+export declare const useCartStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useChooseImageStore.d.ts

@@ -0,0 +1,11 @@
+type OnChange = (images: string[]) => void;
+interface Options {
+    openModal: boolean;
+    setOpenModal: (openModal: boolean) => void;
+    onChange: OnChange | null;
+    setOnChange: (onChange: OnChange) => void;
+    tip: string;
+    setTip: (tip: string) => void;
+}
+export declare const useChooseImageStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useConfirmationModalStore.d.ts

@@ -0,0 +1,10 @@
+interface Options {
+    title: string | null;
+    description: string | null;
+    onConfirm: (() => void) | null;
+    setTitle: (title: string | null) => void;
+    setDescription: (description: string | null) => void;
+    setOnConfirm: (onConfirm: (() => void) | null) => void;
+}
+export declare const useConfirmationModalStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useCustomerDashboardStore.d.ts

@@ -0,0 +1,37 @@
+import { AntistockRoutes, Routes } from '@storefront/constants';
+import { BalanceTopUpSettings, GatewayDetail } from '@storefront/models';
+import { Actions } from '../constants/actions';
+export interface DashInfo {
+    email: string;
+    id: number;
+}
+export interface Balance {
+    amount: number;
+    currency: string;
+}
+interface Options {
+    route: Routes | AntistockRoutes;
+    setRoute: (route: Routes | AntistockRoutes) => void;
+    action: Actions | null;
+    setAction: (action: Actions | null) => void;
+    otpRequest: {
+        requested: boolean;
+        email: string;
+    };
+    setOtpRequest: (otpRequest: {
+        requested: boolean;
+        email: string;
+    }) => void;
+    balanceSettings: BalanceTopUpSettings | null;
+    setBalanceSettings: (balanceSettings: BalanceTopUpSettings | null) => void;
+    gatewaysDetail: GatewayDetail[] | null;
+    setGatewaysDetail: (gatewaysDetail: GatewayDetail[] | null) => void;
+    dashInfo: DashInfo | null;
+    setDashInfo: (dashInfo: DashInfo | null) => void;
+    balance: Balance | null;
+    setBalance: (balance: Balance | null) => void;
+    isBalanceModalOpen: boolean;
+    setIsBalanceModalOpen: (isOpen: boolean) => void;
+}
+export declare const useCustomerDashboardStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useDiscordStore.d.ts

@@ -0,0 +1,7 @@
+import { DiscordUser } from '@storefront/models';
+interface Options {
+    discordInfo: DiscordUser | null;
+    setDiscordInfo: (discordInfo: DiscordUser | null) => void;
+}
+export declare const useDiscordStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useErrorStore.d.ts

@@ -0,0 +1,12 @@
+interface Error {
+    message: string;
+    failedPageIds: number[];
+    failedThemeSettings: boolean;
+    failedSettings: boolean;
+}
+interface Options {
+    error: Error | null;
+    setError: (error: Error | null) => void;
+}
+export declare const useErrorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useGeneralStore.d.ts

@@ -0,0 +1,9 @@
+import { ShopInfo } from '@storefront/models';
+interface Options {
+    general: ShopInfo | null;
+    setGeneral: (general: ShopInfo | null) => void;
+    isAntistock: boolean;
+    setIsAntistock: (isAntistock: boolean) => void;
+}
+export declare const useGeneralStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useHistoryState.d.ts

@@ -0,0 +1,20 @@
+import { useThemeSettingsStore } from '@storefront/store';
+import { useLayersStore } from '@storefront/store';
+import { useSettingsStore } from '@storefront/store';
+interface UndoRedoSnapshot {
+    themeSettings?: ReturnType<typeof useThemeSettingsStore.getState>['themeSettings'];
+    layers?: ReturnType<typeof useLayersStore.getState>['blocks'];
+    header?: ReturnType<typeof useLayersStore.getState>['header'];
+    footer?: ReturnType<typeof useLayersStore.getState>['footer'];
+    announcement?: ReturnType<typeof useLayersStore.getState>['announcement'];
+    settings?: ReturnType<typeof useSettingsStore.getState>['settings'];
+}
+interface HistoryState {
+    past: UndoRedoSnapshot[];
+    future: UndoRedoSnapshot[];
+    addHistory: (snapshot: UndoRedoSnapshot) => void;
+    undo: () => void;
+    redo: () => void;
+}
+export declare const useHistoryStore: import("zustand").UseBoundStore<import("zustand").StoreApi<HistoryState>>;
+export {};

package/dist/src/storefront/store/useLayersStore.d.ts

@@ -0,0 +1,42 @@
+interface Options {
+    header: Record<string, any> | null;
+    footer: Record<string, any> | null;
+    announcement: Record<string, any> | null;
+    blocks: Record<string, {
+        data: Record<string, any>;
+        order: string[];
+    }>;
+    currentBlock: string | null;
+    positionBlock: number | null;
+    setBlocks: (blocks: Record<string, {
+        data: Record<string, any>;
+        order: string[];
+    }>) => void;
+    setHeader: (header: Record<string, any>, addHistory?: boolean) => void;
+    setFooter: (footer: Record<string, any>, addHistory?: boolean) => void;
+    setAnnouncement: (announcement: Record<string, any> | null, addHistory?: boolean) => void;
+    createPage: (name: string) => void;
+    deletePage: (name: string) => void;
+    updatePage: (oldName: string, newName: string) => void;
+    setPositionBlock: (blockId: string | null, insertBelow: boolean) => void;
+    addBlock: (path: string, any: any) => string;
+    editBlock: (path: string, id: string, any: any) => void;
+    removeBlock: (path: string, blockName: string) => void;
+    setCurrentBlock: (blockName: string | null) => void;
+    moveBlock: (path: string, fromIndex: number, toIndex: number) => void;
+    duplicateBlock: (path: string, id: string) => void;
+    isLoadingLayers: boolean;
+    setIsLoadingLayers: (isLoadingLayers: boolean) => void;
+}
+export declare const useLayersStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<Options>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<Options, Options>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: Options) => void) => () => void;
+        onFinishHydration: (fn: (state: Options) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<Options, Options>>;
+    };
+}>;
+export {};

package/dist/src/storefront/store/useModalStore.d.ts

@@ -0,0 +1,6 @@
+interface Options {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+}
+export declare const useModalStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useNavbarStore.d.ts

@@ -0,0 +1,7 @@
+import { NavbarBlock } from '@constants';
+interface Options {
+    activeBlock: NavbarBlock;
+    setActiveBlock: (activeBlock: NavbarBlock) => void;
+}
+export declare const useNavbarStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useNotificationStore.d.ts

@@ -0,0 +1,7 @@
+import { Notification } from '@constants';
+interface Options {
+    notifications: Notification[];
+    setNotifications: (notifications: Notification[]) => void;
+}
+export declare const useNotificationStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/usePagesStore.d.ts

@@ -0,0 +1,33 @@
+import { Page } from '@constants';
+import { PageContext } from '../../abstractions';
+interface Options {
+    pages: Record<string, Page> | null;
+    setPages: (pages: Record<string, Page> | null) => void;
+    pageContext: PageContext;
+    currentPage: string;
+    isOpenModal: boolean;
+    isOpenSelectModal: boolean;
+    isEdit: boolean;
+    editedPage: string | null;
+    setEditedPage: (editedPage: string | null) => void;
+    setCurrentPage: (currentPage: string) => void;
+    setPageContext: (pageContext: PageContext) => void;
+    setIsOpenModal: (isOpenModal: boolean) => void;
+    setIsOpenSelectModal: (isOpenSelectModal: boolean) => void;
+    setIsEdit: (isEdit: boolean) => void;
+    createPage: (page: Page) => void;
+    updatePage: (id: string, page: Page) => void;
+    deletePage: (id: string) => void;
+}
+export declare const usePagesStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<Options>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<Options, Options>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: Options) => void) => () => void;
+        onFinishHydration: (fn: (state: Options) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<Options, Options>>;
+    };
+}>;
+export {};

package/dist/src/storefront/store/usePaginationPagesStore.d.ts

@@ -0,0 +1,7 @@
+interface Options {
+    page: number;
+    setPage: (page: number) => void;
+    resetPage: () => void;
+}
+export declare const usePaginationPagesStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/usePreviewStore.d.ts

@@ -0,0 +1,26 @@
+interface Options {
+    onPreview: boolean;
+    setOnPreview: (onPreview: boolean) => void;
+    activeBlock: {
+        id: string | null;
+        neededScroll: boolean;
+    };
+    setActiveBlock: (activeBlock: {
+        id: string | null;
+        neededScroll: boolean;
+    }) => void;
+    zoomLevel: number;
+    setZoomLevel: (zoomLevel: number) => void;
+}
+export declare const usePreviewStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<Options>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<Options, Options>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: Options) => void) => () => void;
+        onFinishHydration: (fn: (state: Options) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<Options, Options>>;
+    };
+}>;
+export {};

package/dist/src/storefront/store/useSettingsStore.d.ts

@@ -0,0 +1,12 @@
+import { ISettings } from '../../abstractions/index.js';
+type Settings = ISettings & {
+    [key: string]: any;
+};
+interface Options {
+    settings: Settings | null;
+    setSettings: (settings: Settings | null) => void;
+    isLoadingSettings: boolean;
+    setIsLoadingSettings: (isLoadingSettings: boolean) => void;
+}
+export declare const useSettingsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useShareLinkStore.d.ts

@@ -0,0 +1,6 @@
+interface Options {
+    isOpenModal: boolean;
+    setIsOpenModal: (isOpenModal: boolean) => void;
+}
+export declare const useShareLinkStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useStorefrontStore.d.ts

@@ -0,0 +1,23 @@
+import { ShopInfo, ShopPrivacyPolicy, ShopRefundPolicy, ShopTerms } from '@storefront/models';
+interface StorefrontOptions {
+    token: string | null;
+    setToken: (token: string | null) => void;
+    shopDomain: string;
+    setShopDomain: (domain: string) => void;
+    shopId: string;
+    setShopId: (id: string) => void;
+    shopPassword: string;
+    setShopPassword: (password: string) => void;
+    shopGeneral: ShopInfo | null;
+    setShopGeneral: (general: ShopInfo | null) => void;
+    shopTerms: ShopTerms | null;
+    setShopTerms: (terms: ShopTerms | null) => void;
+    shopPrivacyPolicy: ShopPrivacyPolicy | null;
+    setShopPrivacyPolicy: (policy: ShopPrivacyPolicy | null) => void;
+    shopRefundPolicy: ShopRefundPolicy | null;
+    setShopRefundPolicy: (policy: ShopRefundPolicy | null) => void;
+    shopLogo: React.ReactElement | null;
+    setShopLogo: (logo: React.ReactElement | null) => void;
+}
+export declare const useStorefrontStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StorefrontOptions>>;
+export {};

package/dist/src/storefront/store/useSubscriptionStore.d.ts

@@ -0,0 +1,7 @@
+import type { SubscriptionFullItem } from '@storefront/models';
+interface Options {
+    subscription: SubscriptionFullItem | null;
+    setSubscription: (subscription: SubscriptionFullItem | null) => void;
+}
+export declare const useSubscriptionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/store/useThemeSettingsStore.d.ts

@@ -0,0 +1,21 @@
+import { BorderFields, ButtonFields, FontFields, FontType, FontTypeHeading, FontTypeBody, ThemeSettings, ThemeSettingsBlock } from '@constants';
+interface Options {
+    activeBlock: ThemeSettingsBlock | null;
+    setActiveBlock: (activeBlock: ThemeSettingsBlock | null) => void;
+    themeSettings: ThemeSettings;
+    setThemeSettings: (themeSettings: ThemeSettings) => void;
+    updateColor: (category: keyof ThemeSettings['colors'], colorType: string, newColor: string) => void;
+    updateFont: (deviceType: 'mobile' | 'tablet' | 'desktop', fontType: FontType, id: FontTypeHeading | FontTypeBody, field: keyof FontFields, newValue: string | number) => void;
+    updateBorder: (field: keyof BorderFields, newValue: string | number) => void;
+    updateButton: (category: keyof ThemeSettings['buttons'], field: keyof ButtonFields, newValue: string | number | boolean | object) => void;
+    activeColorCategory: keyof ThemeSettings['colors'] | null;
+    setActiveColorCategory: (activeColorCategory: keyof ThemeSettings['colors'] | null) => void;
+    activeFont: FontTypeHeading | FontTypeBody | null;
+    setActiveFont: (activeFont: FontTypeHeading | FontTypeBody | null) => void;
+    updateInput: (category: keyof ThemeSettings['inputs'], value: string | number | boolean, field: keyof ThemeSettings['inputs']['general'] | keyof ThemeSettings['inputs']['border'] | keyof ThemeSettings['inputs']['label'] | keyof ThemeSettings['inputs']['field']) => void;
+    updateFontSizePercentage: (fontType: 'mobile' | 'tablet', newValue: number) => void;
+    isLoadingThemeSettings: boolean;
+    setIsLoadingThemeSettings: (isLoadingThemeSettings: boolean) => void;
+}
+export declare const useThemeSettingsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<Options>>;
+export {};

package/dist/src/storefront/ui/ActiveBadge/index.d.ts

@@ -0,0 +1,5 @@
+interface ActiveBadgeProps {
+    className?: string;
+}
+export declare const ActiveBadge: React.FC<ActiveBadgeProps>;
+export {};

package/dist/src/storefront/ui/InputRange/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface Props {
+    totalSteps: number;
+    step: number;
+    onStepChange: (step: number) => void;
+    label?: string;
+}
+export declare const InputRange: React.FC<Props>;
+export {};

package/dist/src/storefront/ui/ProgressBar/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ProgressBarProps {
+    percent: number;
+    color?: string;
+    disablePercentLabel?: boolean;
+}
+export declare const ProgressBar: React.FC<ProgressBarProps>;
+export {};

package/dist/src/storefront/ui/Rating/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface RatingProps {
+    rating: number;
+    setRating: (value: number) => void;
+    disabled?: boolean;
+}
+export declare const Rating: React.FC<RatingProps>;
+export {};