@returnflows/shop-overlay 1.0.0

package/dist/types/widget/lib/hooks/common/use-value-state.d.ts

@@ -0,0 +1,7 @@
+type Setter<T> = React.Dispatch<React.SetStateAction<T>>;
+export interface ValueState<T> {
+    value: T;
+    set: Setter<T>;
+}
+declare const useValueState: <T>(initialState: T, stateUpdateCallback?: (newValue: T) => void) => Readonly<ValueState<T>>;
+export default useValueState;

package/dist/types/widget/lib/hooks/common/use-y-scrollable.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from "preact";
+interface UseYScrollableReturn extends ScrollState {
+    isYScrollable: boolean;
+}
+interface ScrollState {
+    isDirty: boolean;
+    isScrolling: boolean;
+}
+declare const useYScrollable: <T extends HTMLElement>(ref: RefObject<T>) => UseYScrollableReturn;
+export default useYScrollable;

package/dist/types/widget/lib/hooks/context/use-calculation.d.ts

@@ -0,0 +1,12 @@
+declare const useCalculation: () => {
+    orderTotal: number;
+    cartTotal: number;
+    returnTotal: number;
+    giftcardValue: number;
+    totalPriceDiscount: number;
+    giftCardBonusAmount: number;
+    returnLabelPrice: number;
+    isRefunding: boolean;
+    itemCount: number;
+};
+export default useCalculation;

package/dist/types/widget/lib/hooks/context/use-cart-items.d.ts

@@ -0,0 +1,9 @@
+import { ExtendedShopifyProduct } from "../../../components/drawer/product/product";
+/**
+ * Merges cart items with their corresponding exchange calculation details.
+ * Returns cart items enriched with pricing information from the calculation state.
+ */
+declare const useCartItems: () => {
+    cartItems: ExtendedShopifyProduct[];
+};
+export default useCartItems;

package/dist/types/widget/lib/hooks/context/use-currency.d.ts

@@ -0,0 +1,12 @@
+import { NumberFormatOptions } from "use-intl";
+type TCurrencyDisplayOptions = NumberFormatOptions["currencyDisplay"] | "none";
+interface ICurrencyFormatOptions extends Omit<NumberFormatOptions, "style" | "currencyDisplay"> {
+    currencyDisplay?: TCurrencyDisplayOptions;
+    fractionDigits?: number;
+}
+declare const useCurrency: (hookOptions?: ICurrencyFormatOptions) => {
+    format: (value: number | string, options?: ICurrencyFormatOptions) => string;
+    applyExchangeRate: (value: number) => number;
+    currency: string;
+};
+export default useCurrency;

package/dist/types/widget/lib/hooks/context/use-errors.d.ts

@@ -0,0 +1,2 @@
+declare const useErrors: () => import("../../context/error-context").IErrorContext;
+export default useErrors;

package/dist/types/widget/lib/hooks/context/use-navigation.d.ts

@@ -0,0 +1,6 @@
+declare const useNavigation: () => {
+    back: (fallbackProductId?: string) => Promise<void>;
+    continue: () => void;
+    exit: (clearCartOnExit?: boolean) => Promise<void>;
+};
+export default useNavigation;

package/dist/types/widget/lib/hooks/context/use-return-context.d.ts

@@ -0,0 +1,2 @@
+declare const useReturnContext: () => import("../../context/return-context").IReturnContext;
+export default useReturnContext;

package/dist/types/widget/lib/hooks/context/use-root.d.ts

@@ -0,0 +1,2 @@
+declare const useRoot: () => () => HTMLElement | null;
+export default useRoot;

package/dist/types/widget/lib/hooks/context/use-theme.d.ts

@@ -0,0 +1,5 @@
+declare const useTheme: () => {
+    theme: import("../../../..").ThemeVariables | null | undefined;
+    cssVariables: import("preact").JSX.CSSProperties | undefined;
+};
+export default useTheme;

package/dist/types/widget/lib/hooks/context/use-toast.d.ts

@@ -0,0 +1,2 @@
+declare const useToast: () => import("../../context/toast-context").IToastContext;
+export default useToast;

package/dist/types/widget/lib/hooks/context/use-widget-context.d.ts

@@ -0,0 +1,2 @@
+declare const useWidgetContext: () => import("../../context/widget-context").IWidgetContext;
+export default useWidgetContext;

package/dist/types/widget/lib/hooks/feature/use-api-bridge.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook that registers the widget's React state with the API bridge.
+ * This allows the public API to interact with the widget's internal state.
+ */
+declare const useApiBridge: () => void;
+export default useApiBridge;

package/dist/types/widget/lib/hooks/feature/use-cart-activator.d.ts

@@ -0,0 +1,2 @@
+declare const useCartActivator: () => void;
+export default useCartActivator;

package/dist/types/widget/lib/hooks/feature/use-external-events.d.ts

@@ -0,0 +1,2 @@
+declare const useExternalEvents: () => void;
+export default useExternalEvents;

package/dist/types/widget/lib/hooks/feature/use-fetch-interceptor.d.ts

@@ -0,0 +1,4 @@
+declare const useFetchInterceptor: () => {
+    initialized: boolean;
+};
+export default useFetchInterceptor;

package/dist/types/widget/lib/hooks/feature/use-override-scroll-blocking.d.ts

@@ -0,0 +1,2 @@
+declare const useOverrideScrollBlocking: () => void;
+export default useOverrideScrollBlocking;

package/dist/types/widget/lib/types.d.ts

@@ -0,0 +1,382 @@
+type GlobalShopify = {
+    shop: string;
+    locale: string;
+    currency: {
+        active: string;
+        rate: string;
+    };
+    country: string;
+    theme: {
+        name: string;
+        id: number;
+        schema_name: string;
+        schema_version: string;
+        theme_store_id?: number;
+        role: string;
+        handle: string;
+        style: {
+            id?: string | null;
+            handle?: string | null;
+        };
+    };
+    cdnHost: string;
+    routes: {
+        root: string;
+    };
+    ce_forms: {
+        q: Array<unknown>;
+    };
+    captcha: unknown;
+    PaymentButton: {
+        isStorefrontPortableWallets: boolean;
+    };
+    analytics: {
+        replayQueue: Array<unknown>;
+        initialized: boolean;
+    };
+    modules: boolean;
+    featureAssets: {
+        "shop-js": unknown;
+    };
+};
+type InterceptionProperties = {
+    rf_interception?: boolean;
+};
+declare global {
+    interface Window {
+        __rf_original_fetch?: typeof fetch;
+        fetch: typeof fetch & InterceptionProperties;
+        __rf_original_xhr?: typeof XMLHttpRequest;
+        XMLHttpRequest: typeof XMLHttpRequest & InterceptionProperties;
+        __rf_original_search?: string;
+        Shopify: GlobalShopify;
+    }
+}
+export type ReturnAction = "swap" | "exchange" | "giftcard" | "refund";
+export type ProductRule = {
+    id: string;
+    type: "NO_RETURN" | "NO_REFUND" | "EXTEND_PERIOD" | "NO_EXCHANGE_TO";
+    extendedBy: number;
+    marketId: string;
+    updatedAt: string;
+    createdAt: string;
+    products: Array<{
+        title: string;
+        image: string;
+        id: string;
+        ruleId: string;
+        shopifyProductId: string;
+        createdAt: string;
+    }>;
+};
+export interface ShopOverlayData {
+    id: string;
+    orderId: string;
+    orderName: string;
+    instantExchange: boolean;
+    freeExchangeLabel: boolean;
+    productsToExchange: Array<OrderProduct>;
+    totalPrice: number;
+    productRules: Array<ProductRule>;
+    returnWindows: {
+        exchangeReturnWindow: boolean;
+        refundReturnWindow: boolean;
+    };
+}
+export interface OrderProduct {
+    id: string;
+    shopifyLineId: string;
+    title: string;
+    variantTitle: string;
+    image: string;
+    handle: string;
+    price: number;
+    quantity: number;
+}
+export interface ShopifyCartAddResponse {
+    id: number;
+    properties: Record<string, unknown>;
+    quantity: number;
+    variant_id: number;
+    key: string;
+    title: string;
+    product_title: string;
+    variant_title: string;
+    price: number;
+    original_price: number;
+    discounted_price: number;
+    line_price: number;
+    original_line_price: number;
+    presentment_price: number;
+    total_discount: number;
+    discounts: Array<unknown>;
+    sku: string;
+    grams: number;
+    vendor: string;
+    taxable: boolean;
+    product_id: number;
+    product_has_only_default_variant: boolean;
+    gift_card: boolean;
+    final_price: number;
+    final_line_price: number;
+    url: string;
+    featured_image: {
+        alt: string;
+        aspect_ratio: number;
+        height: number;
+        url: string;
+        width: number;
+    };
+    image: string;
+    handle: string;
+    requires_shipping: boolean;
+    product_type: string;
+    untranslated_product_title: string;
+    product_description: string;
+    untranslated_variant_title: string;
+    variant_options: Array<string>;
+    options_with_values: Array<{
+        name: string;
+        value: string;
+    }>;
+    line_level_discount_allocations: Array<unknown>;
+    line_level_total_discount: number;
+    sections: {
+        "cart-notification-product": string;
+        "cart-notification-button": string;
+        "cart-icon-bubble": string;
+    };
+}
+export interface ShopifyCart {
+    items: Array<ShopifyCartItem>;
+    item_count: number;
+    token?: string;
+    note?: string;
+    attributes?: Record<string, unknown>;
+    original_total_price?: number;
+    total_price?: number;
+    total_discount?: number;
+    total_weight?: number;
+    requires_shipping?: boolean;
+    currency?: string;
+    items_subtotal_price?: number;
+    cart_level_discount_applications?: Array<unknown>;
+    discount_codes?: Array<unknown>;
+}
+export interface ShopifyCartChangeResponse extends ShopifyCart {
+    items_added: Array<ShopifyCartItem>;
+    items_removed: Array<ShopifyCartItem>;
+}
+export interface ShopifyCartItem {
+    variant_id: number;
+    quantity: number;
+    title: string;
+    price: number;
+    product_id: number;
+    product_title: string;
+    handle: string;
+    image: string;
+    grams: number;
+    line_price: number;
+    final_price: number;
+    final_line_price: number;
+    id?: number;
+    line_id?: string;
+    merchandise_id?: string;
+    properties?: Record<string, unknown>;
+    key?: string;
+    variant_title?: string;
+    quantity_rule?: {
+        min: number | null;
+        max: number | null;
+        increment: number | null;
+    };
+    original_price?: number;
+    presentment_price?: number;
+    discounted_price?: number;
+    original_line_price?: number;
+    total_discount?: number;
+    discounts?: Array<unknown>;
+    sku?: string;
+    vendor?: string;
+    taxable?: boolean;
+    product_has_only_default_variant?: boolean;
+    gift_card?: boolean;
+    url?: string;
+    featured_image?: {
+        aspect_ratio: number;
+        alt: string;
+        height: number;
+        url: string;
+        width: number;
+    };
+    requires_shipping?: boolean;
+    product_type?: string;
+    product_description?: string;
+    variant_options?: Array<string>;
+    options_with_values?: Array<{
+        name: string;
+        value: string;
+    }>;
+    line_level_discount_allocations?: Array<unknown>;
+    line_level_total_discount?: number;
+    has_components?: boolean;
+}
+export interface ShopifyErrorResponse {
+    status: string;
+    message: string;
+    description: string;
+}
+export interface CalculationExchangeProduct {
+    variantId: string | undefined;
+    productId: string;
+    productTitle: string;
+    price: number;
+    compareAtPrice: number | null;
+    coverage: {
+        originalProductId: string;
+        originalVariantId: string;
+        quantityCovered: number;
+        originalUnitPrice: number;
+        exchangeUnitPrice: number;
+        coveredAmount: number;
+    } | null;
+}
+export interface CalculationLineItem {
+    id: string;
+    lineItemId: string;
+    variantId: string;
+    productId: string;
+    quantity: number;
+    lineItemDistributionKey: number;
+    action: "NOT_DECIDED" | "REFUND" | "EXCHANGE" | "SWAP" | "GIFTCARD";
+    originalPrice: number;
+    price: number;
+    discountedPrice: number;
+    originalTotal: number;
+    total: number;
+    discountedTotal: number;
+    metafield: {
+        namespace: unknown;
+        key: unknown;
+        value: unknown;
+    };
+}
+export interface CalculationResponse {
+    percentageOfReturn: number;
+    returnLabelPrice: number;
+    giftCardBonusAmount: number;
+    refundMethods: {
+        refund: number;
+        giftcard: number;
+        exchange: number;
+    };
+    distributionKeysByAction: {
+        REFUND: number;
+        EXCHANGE: number;
+        GIFTCARD: number;
+    };
+    shipping: {
+        amount: number;
+        amountInCurrency: number;
+        originalOrderShipping: number;
+    };
+    orderDiscounts: Array<unknown>;
+    discountSummary: {
+        originalDiscountTotal: number;
+        adjustedDiscountTotal: number;
+        appliedToReturnSubtotal: number;
+        hasDiscounts: boolean;
+        hasAdjustedDiscounts: boolean;
+        discountAppliedToExchange: boolean;
+        discountAddedToReturnSubtotal: boolean;
+        shippingRefundAppliedToReturnSubtotal: boolean;
+    };
+    lineItems: Array<CalculationLineItem>;
+    exchange: {
+        originalTotal: number;
+        newTotal: number;
+        priceDifference: number;
+        isUpsell: boolean;
+        additionalCharge: number;
+        totalCoveredAmount: number;
+        discountSummary: {
+            originalDiscountTotal: number;
+            adjustedDiscountTotal: number;
+            appliedToReturnSubtotal: number;
+            hasDiscounts: boolean;
+            hasAdjustedDiscounts: boolean;
+            discountAppliedToExchange: boolean;
+            discountAddedToReturnSubtotal: boolean;
+            shippingRefundAppliedToReturnSubtotal: boolean;
+        };
+        exchangeDetails: Array<CalculationExchangeProduct>;
+    };
+    currency: {
+        localCurrency: string;
+        shopCurrency: string;
+        exchangeRate: number;
+    };
+    options: {
+        coverPriceChange: boolean;
+        orderDiscountMatch: boolean;
+        productDiscountMatch: boolean;
+        giftCardBonusPercentage: number;
+        refundOriginalShippingType: string;
+    };
+    returnSubtotal: number;
+    orderSubtotal: number;
+    preferedLabelDeduction: string;
+    total: number;
+    calculatedAt: string;
+    detailedBreakdown: {
+        originalOrder: {
+            subtotal: number;
+            shipping: number;
+            discounts: Array<unknown>;
+            total: number;
+        };
+        return: {
+            subtotal: {
+                items: number;
+                returnLabelPrice: number;
+                shippingRefund: number;
+                discounts: Array<unknown>;
+                total: number;
+            };
+            refundMethods: {
+                refund: {
+                    amount: number;
+                    description: string;
+                };
+                giftcard: {
+                    baseAmount: number;
+                    bonusAmount: number;
+                    bonusPercentage: number;
+                    totalAmount: number;
+                };
+                exchange: {
+                    amount: number;
+                    priceDifference: number;
+                    finalAmount: number;
+                };
+            };
+            total: number;
+        };
+        preferedLabelDeduction: string;
+        currency: {
+            localCurrency: string;
+            shopCurrency: string;
+            exchangeRate: number;
+        };
+    };
+}
+export declare enum WidgetViewState {
+    Collapsed = "COLLAPSED",
+    Open = "OPEN"
+}
+export declare enum ReturnViewState {
+    Collapsed = "COLLAPSED",
+    Open = "OPEN"
+}
+export {};

package/dist/types/widget/lib/utils/api.d.ts

@@ -0,0 +1,26 @@
+import { CalculationParams } from "../../components/providers/return-context-provider";
+import { CalculationResponse, ShopifyCart, ShopOverlayData } from "../types";
+import { WidgetConfiguration } from "./initialization/types";
+import { StorageKey } from "./storage";
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+interface FetchStoreOptions extends StorageKey {
+    storeResult?: boolean;
+    shouldUseCachedResult?: boolean;
+    logging?: boolean;
+    expiration?: number;
+}
+interface FetchAPIOptions extends Omit<RequestInit, "body" | "method"> {
+    method?: HttpMethod;
+    body?: unknown;
+    params?: Record<string, string | number | boolean> | URLSearchParams;
+    clientStorage?: FetchStoreOptions;
+}
+export declare function apiQuery<T>(path: string, { clientStorage: storageOptions, ...init }?: FetchAPIOptions): Promise<T>;
+export declare function getCalculation({ orderId, cart, lineItems }: CalculationParams, labelCount: number): Promise<CalculationResponse>;
+export declare function getShopOverlayData(isFirstLoad: boolean, internalReturnId: string, lineIds: string): Promise<ShopOverlayData>;
+export type ProcessOrderInitializationReturn = {
+    orderData: ShopOverlayData;
+    updatedCart: ShopifyCart | null;
+};
+export declare function processOrderInitialization({ isFirstLoad, options: { clearCartOnStart }, id: internalId, data: cache }: WidgetConfiguration): Promise<ProcessOrderInitializationReturn>;
+export {};

package/dist/types/widget/lib/utils/cart-provider-store.d.ts

@@ -0,0 +1,3 @@
+import type { CartInput, CartProvider, ShopifyCart } from "../../../api/types";
+export declare function getInternalCartProvider<T extends CartInput = ShopifyCart>(): CartProvider<T> | null;
+export declare function hasCartProvider(): boolean;

package/dist/types/widget/lib/utils/cart.d.ts

@@ -0,0 +1,17 @@
+import { ProductRule, ShopifyCart, ShopifyCartChangeResponse } from "../types";
+export declare function getRuleProductIds(rules: ProductRule[], type: ProductRule["type"]): number[];
+export declare function normalizeCart<T extends ShopifyCart>(cart: T, rules: ProductRule[]): T;
+export declare function compareCarts(cart1: ShopifyCart, cart2: ShopifyCart, rules: ProductRule[]): boolean;
+export declare function getCart(preferStorage?: boolean): Promise<ShopifyCart>;
+export declare function clearCart(): Promise<ShopifyCart>;
+export declare function setCartItems(items: Array<{
+    id: number;
+    quantity: number;
+}>): Promise<ShopifyCart>;
+export declare function updateCartItemQuantity({ variantId, quantity, isRetry }: {
+    variantId: number;
+    quantity: number;
+    isRetry?: boolean;
+}): Promise<ShopifyCartChangeResponse | ShopifyCart>;
+export declare function updateCartStorage(cart: ShopifyCart | null): void;
+export declare function getCartStorage(): ShopifyCart | null;

package/dist/types/widget/lib/utils/custom-events.d.ts

@@ -0,0 +1,48 @@
+import { WidgetViewState } from "../types";
+import { WidgetConfiguration } from "./initialization/types";
+export declare const enum InternalCustomEvent {
+    FetchInterception = "RF_FETCH_INTERCEPTION",
+    XHRInterception = "RF_XHR_INTERCEPTION",
+    DrawerStateChange = "RF_DRAWER_STATE_CHANGE",
+    WidgetInitialization = "RF_WIDGET_INITIALIZATION"
+}
+export declare const enum ExternalCustomEvent {
+    DrawerOpen = "RF_DRAWER_OPEN",
+    DrawerClose = "RF_DRAWER_CLOSE",
+    DrawerToggle = "RF_DRAWER_TOGGLE",
+    CalculationRefetch = "RF_CALCULATION_REFETCH",
+    CartRefetch = "RF_CART_REFETCH",
+    CartAndCalculationRefetch = "RF_CART_AND_CALCULATION_REFETCH",
+    DrawerOpenAndRefetch = "RF_DRAWER_OPEN_AND_REFETCH"
+}
+export type XHRResponse = string | Record<string, unknown> | undefined;
+export type FetchResponse = Response | undefined;
+export type InterceptionResponse = XHRResponse | FetchResponse;
+export interface InterceptionPayload {
+    response: InterceptionResponse;
+    requestUrl: string | URL;
+}
+export type CustomEventPayloadMap = {
+    [InternalCustomEvent.FetchInterception]: InterceptionPayload;
+    [InternalCustomEvent.XHRInterception]: InterceptionPayload;
+    [InternalCustomEvent.DrawerStateChange]: {
+        state: WidgetViewState;
+    };
+    [InternalCustomEvent.WidgetInitialization]: WidgetConfiguration;
+    [ExternalCustomEvent.DrawerOpen]: undefined;
+    [ExternalCustomEvent.DrawerClose]: undefined;
+    [ExternalCustomEvent.DrawerToggle]: undefined;
+    [ExternalCustomEvent.CalculationRefetch]: undefined;
+    [ExternalCustomEvent.CartRefetch]: undefined;
+    [ExternalCustomEvent.CartAndCalculationRefetch]: undefined;
+    [ExternalCustomEvent.DrawerOpenAndRefetch]: undefined;
+};
+declare function subscribe<K extends keyof CustomEventPayloadMap>(eventName: K, callback: (event: CustomEvent<CustomEventPayloadMap[K]>) => void): () => void;
+declare function publish<K extends InternalCustomEvent>(eventName: K, ...args: K extends keyof CustomEventPayloadMap ? [detail: CustomEventPayloadMap[K]] : [detail?: undefined]): void;
+declare function unsubscribe<K extends keyof CustomEventPayloadMap>(eventName: K, callback: (event: CustomEvent<CustomEventPayloadMap[K]>) => void): void;
+declare const customEvents: {
+    subscribe: typeof subscribe;
+    publish: typeof publish;
+    unsubscribe: typeof unsubscribe;
+};
+export default customEvents;

package/dist/types/widget/lib/utils/dom.d.ts

@@ -0,0 +1,2 @@
+export declare const removeInertFromElements: () => void;
+export declare function cloneAndReplaceElement<T extends HTMLElement>(element: T): T;

package/dist/types/widget/lib/utils/errors.d.ts

@@ -0,0 +1,6 @@
+export declare enum ProductErrorState {
+    Unknown = "unknown_error",
+    NetworkError = "network_error",
+    ProductLimit = "product_limit"
+}
+export declare function getErrorStateFromCode(code: number | null): ProductErrorState;

package/dist/types/widget/lib/utils/helpers.d.ts

@@ -0,0 +1,24 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function assert(variable: unknown, message: string): asserts variable;
+export declare function wait(ms: number): Promise<unknown>;
+export declare function isNil(value: unknown): value is null | undefined;
+export declare function ensureHttpUrl(url: string, secure?: boolean): string;
+export declare function isNumber(value: unknown): value is number;
+export declare function hexToHsl(hex: string): string;
+export declare function isOnCartPage(): boolean;
+interface WrapperOptions {
+    shouldThrow?: boolean;
+    logError?: boolean;
+    fallbackValue?: unknown;
+}
+export declare function attempt<T, TThrow extends boolean = false>(fn: () => T, errorMessage: string, options?: WrapperOptions & {
+    shouldThrow?: TThrow;
+}): TThrow extends true ? T : T | undefined;
+export declare function parseToNumber(value: string | number | null | undefined, fallback?: number): number;
+export declare function daysToMilliseconds(days: number): number;
+export declare function secondsToMilliseconds(seconds: number): number;
+export declare function setNestedValue<T>(obj: Record<string, unknown>, path: string, value: T): T;
+export declare function getResolvedSearchParams(): URLSearchParams;
+export declare function resolveSetStateAction<T>(action: React.SetStateAction<T>, currentState: T): T;
+export {};

package/dist/types/widget/lib/utils/i18n.d.ts

@@ -0,0 +1,8 @@
+import { Messages } from "use-intl";
+export type Locale = string;
+export declare const DEFAULT_LOCALE: Locale;
+export declare const DEFAULT_CURRENCY: string;
+export declare function loadMessages(...locales: Locale[]): Promise<{
+    messages: Messages;
+    locale: Locale;
+}>;

package/dist/types/widget/lib/utils/initialization/dataset.d.ts

@@ -0,0 +1,5 @@
+import { InitOptions, InitResult, WidgetSettings } from "./types";
+export declare function isDOMStringMap(value: DOMStringMap | InitOptions): value is DOMStringMap;
+export declare function parseScriptDataset(dataset: DOMStringMap): InitOptions;
+export declare function getSettingsFromScript(): WidgetSettings | null;
+export declare function prepareInitializationOptions(dataset: DOMStringMap | InitOptions): Promise<InitResult>;

package/dist/types/widget/lib/utils/initialization/font.d.ts

@@ -0,0 +1,7 @@
+type InjectFontReturn = Promise<[
+    HTMLLinkElement,
+    HTMLLinkElement,
+    HTMLLinkElement
+]>;
+export declare function injectFont(): InjectFontReturn;
+export {};

package/dist/types/widget/lib/utils/initialization/index.d.ts

@@ -0,0 +1,6 @@
+import { ComponentChild } from "preact";
+import { InitOptions, InitResult, WidgetConfiguration } from "./types";
+type RenderNode = (config: WidgetConfiguration) => ComponentChild;
+declare function initialize(renderNode: RenderNode, options: DOMStringMap | InitOptions): Promise<InitResult>;
+export type { InitResult };
+export default initialize;