@swishapp/sdk 0.60.0-beta.1 → 0.60.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type * from "@swishapp/api-client";
+export type * from "./ajax-api/ajax-api-client";
+export type { EventName } from "./events/event-bus";
+export type * from "./storefront-api/storefront-api-client";
+export type * from "./intents/types";
+export { SwishApp } from "./swish";
+export type { Ref, SwishUiElement } from "./swish-ui/swish-ui-element";
+export type { Toast, ToastManager, UnsaveAlertSubmitData, ListSelectSubmitData, VariantSelectSubmitData, UnsaveAlertOptions, ListSelectOptions, VariantSelectOptions, QuickBuySubmitData, QuickBuyOptions, } from "./swish-ui/swish-ui-utils";
+export type { ShopBridge } from "./utils/shop-bridge";

package/dist/intents/intent-handler.d.ts

@@ -1,10 +1,10 @@
 import { SwishApp } from "../swish";
-import { IntentOptionsWithDefaults } from "./intents";
+import { IntentOptions } from "./intents";
 import { Intent, IntentEventBus, IntentResponse } from "./types";
 export declare abstract class IntentHandler<T extends Intent = Intent> {
     protected readonly swish: SwishApp;
     protected readonly eventBus: IntentEventBus;
-    protected readonly options: IntentOptionsWithDefaults;
-    constructor(swish: SwishApp, eventBus: IntentEventBus, options: IntentOptionsWithDefaults);
+    protected readonly options: IntentOptions;
+    constructor(swish: SwishApp, eventBus: IntentEventBus, options: IntentOptions);
     abstract invoke(intent: T): Promise<IntentResponse<T>>;
 }

package/dist/intents/intent-hook.d.ts

@@ -1,9 +1,9 @@
-import type { SwishApp } from "../swish";
-import type { IntentOptionsWithDefaults } from "./intents";
-import type { Intent, IntentResponse } from "./types";
+import { SwishApp } from "../swish";
+import { IntentOptions } from "./intents";
+import { Intent, IntentResponse } from "./types";
 export declare abstract class IntentHook<T extends Intent = Intent> {
     protected readonly swish: SwishApp;
-    protected readonly options: IntentOptionsWithDefaults;
-    constructor(swish: SwishApp, options: IntentOptionsWithDefaults);
+    protected readonly options: IntentOptions;
+    constructor(swish: SwishApp, options: IntentOptions);
     abstract invoke(respomse: IntentResponse<T>): Promise<void>;
 }

package/dist/intents/intents.d.ts

@@ -1,29 +1,16 @@
 import { SwishApp } from "../swish";
 import { Intent, IntentActivity, IntentQuery, IntentQueryWithParams, IntentResponse } from "./types";
 export interface IntentOptions {
-    save?: {
-        requireVariant?: boolean;
-        showToast?: boolean;
-    };
-    edit?: {
-        showToast?: boolean;
-    };
-    unsave?: {
-        requireConfirmation?: boolean;
-        openEditor?: boolean;
-        showToast?: boolean;
-    };
+    allowSaveWithoutVariant?: boolean;
+    deleteSavedItemsWithoutEdit?: boolean;
+    showToastAfterSave?: boolean;
+    showToastAfterDelete?: boolean;
 }
-export type IntentOptionsWithDefaults = {
-    save: Required<NonNullable<IntentOptions["save"]>>;
-    edit: Required<NonNullable<IntentOptions["edit"]>>;
-    unsave: Required<NonNullable<IntentOptions["unsave"]>>;
-};
 export declare class Intents {
     private readonly swish;
     private readonly eventBus;
     private readonly options;
-    constructor(swish: SwishApp, options?: IntentOptions);
+    constructor(swish: SwishApp, options: IntentOptions);
     publishAnalyticsEvent(event: string, data: Record<string, any>): void;
     invoke<T extends Intent>(intent: T): Promise<IntentActivity<T>>;
     listen(intent: Pick<Intent, "action" | "type">, callback: (response: IntentResponse) => void): () => void;

package/dist/state/index.d.ts

@@ -2,4 +2,3 @@ export { signal, effect, computed } from "@preact/signals-core";
 export * from "./item-context-signal";
 export * from "./item-state-signal";
 export * from "./item-count-signal";
-export * from "./swish-query-signals";

package/dist/storefront-api/load-product-card-data.d.ts

@@ -1,6 +1,6 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
 import type { GetProductCardDataQuery, GetProductCardDataWithVariantQuery } from "./types/storefront.generated";
-import type { CountryCode, HasMetafieldsIdentifier, LanguageCode } from "./types/storefront.types";
+import type { HasMetafieldsIdentifier } from "./types/storefront.types";
 export type LoadProductCardDataResponse = StorefrontApiResponse<GetProductCardDataQuery | GetProductCardDataWithVariantQuery>;
 export type { GetProductCardDataQueryVariables } from "./types/storefront.generated";
 export interface LoadProductCardDataArgs {
@@ -8,10 +8,8 @@ export interface LoadProductCardDataArgs {
     variantId?: string;
     productMetafields?: HasMetafieldsIdentifier[];
     variantMetafields?: HasMetafieldsIdentifier[];
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadProductCardData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, country, language, }: LoadProductCardDataArgs) => Promise<{
+export declare const loadProductCardData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, }: LoadProductCardDataArgs) => Promise<{
     data: GetProductCardDataQuery | GetProductCardDataWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

package/dist/storefront-api/load-product-detail-data.d.ts

@@ -1,6 +1,6 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
 import type { GetProductDetailDataQuery, GetProductDetailDataWithVariantQuery } from "./types/storefront.generated";
-import type { CountryCode, HasMetafieldsIdentifier, LanguageCode } from "./types/storefront.types";
+import type { HasMetafieldsIdentifier } from "./types/storefront.types";
 export type LoadProductDetailDataResponse = StorefrontApiResponse<GetProductDetailDataQuery | GetProductDetailDataWithVariantQuery>;
 export type { GetProductDetailDataQueryVariables } from "./types/storefront.generated";
 export interface LoadProductDetailDataArgs {
@@ -8,10 +8,8 @@ export interface LoadProductDetailDataArgs {
     variantId?: string;
     productMetafields?: HasMetafieldsIdentifier[];
     variantMetafields?: HasMetafieldsIdentifier[];
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadProductDetailData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, country, language, }: LoadProductDetailDataArgs) => Promise<{
+export declare const loadProductDetailData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, }: LoadProductDetailDataArgs) => Promise<{
     data: GetProductDetailDataQuery | GetProductDetailDataWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

package/dist/storefront-api/load-product-images.d.ts

@@ -1,5 +1,4 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
-import type { CountryCode, LanguageCode } from "./types/storefront.types";
 export type LoadProductImagesResponse = StorefrontApiResponse<{
     id: string;
     altText: string;
@@ -11,10 +10,8 @@ export interface LoadProductImagesArgs {
         productId: number;
         variantId?: number | null;
     }[];
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadProductImages: (client: StorefrontApiClient, { items, country, language }: LoadProductImagesArgs) => Promise<{
+export declare const loadProductImages: (client: StorefrontApiClient, { items }: LoadProductImagesArgs) => Promise<{
     data: (Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash"> | undefined)[];
     error: null;
 } | {

package/dist/storefront-api/load-product-options.d.ts

@@ -1,16 +1,13 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
 import type { GetProductOptionsQuery, GetProductOptionsWithVariantQuery } from "./types/storefront.generated";
-import type { CountryCode, LanguageCode } from "./types/storefront.types";
 export type LoadProductOptionsResponse = StorefrontApiResponse<GetProductOptionsQuery | GetProductOptionsWithVariantQuery>;
 export type { GetProductOptionsQueryVariables } from "./types/storefront.generated";
 export interface LoadProductOptionsArgs {
     productId?: string;
     variantId?: string;
     productHandle?: string;
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadProductOptions: (client: StorefrontApiClient, { productId, productHandle, variantId, country, language, }: LoadProductOptionsArgs) => Promise<{
+export declare const loadProductOptions: (client: StorefrontApiClient, { productId, productHandle, variantId }: LoadProductOptionsArgs) => Promise<{
     data: GetProductOptionsQuery | GetProductOptionsWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

package/dist/storefront-api/load-product-recommendations.d.ts

@@ -1,5 +1,5 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
-import type { CountryCode, HasMetafieldsIdentifier, LanguageCode, Product, ProductRecommendationIntent } from "./types/storefront.types";
+import type { HasMetafieldsIdentifier, Product, ProductRecommendationIntent } from "./types/storefront.types";
 export type LoadProductRecommendationsResponse = StorefrontApiResponse<{
     productRecommendations?: Product[] | null;
 }>;
@@ -8,10 +8,8 @@ export interface LoadProductRecommendationsArgs {
     productHandle?: string;
     intent?: ProductRecommendationIntent;
     productMetafields?: HasMetafieldsIdentifier[];
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadProductRecommendations: (client: StorefrontApiClient, { productId, productHandle, intent, productMetafields, country, language, }: LoadProductRecommendationsArgs) => Promise<{
+export declare const loadProductRecommendations: (client: StorefrontApiClient, { productId, productHandle, intent, productMetafields, }: LoadProductRecommendationsArgs) => Promise<{
     data: {
         productRecommendations?: Product[] | null;
     } | undefined;

package/dist/storefront-api/load-save-intent-data.d.ts

@@ -1,13 +1,12 @@
 import { StorefrontApiClient } from "./storefront-api-client";
 import type { GetSaveIntentDataQuery, GetSaveIntentDataWithVariantQuery } from "./types/storefront.generated";
-import { CountryCode, LanguageCode } from "./types/storefront.types";
-export type LoadSaveIntentDataArgs = {
-    productId: string;
-    variantId?: string;
-    country: CountryCode;
-    language: LanguageCode;
-};
-export declare const loadSaveIntentData: (client: StorefrontApiClient, { productId, variantId, country, language }: LoadSaveIntentDataArgs) => Promise<{
+import * as v from "valibot";
+export declare const LoadSaveIntentDataSchema: v.ObjectSchema<{
+    readonly productId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string>]>;
+    readonly variantId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string>]>, undefined>;
+}, undefined>;
+export type LoadSaveIntentDataArgs = v.InferOutput<typeof LoadSaveIntentDataSchema>;
+export declare const loadSaveIntentData: (client: StorefrontApiClient, args: LoadSaveIntentDataArgs) => Promise<{
     data: GetSaveIntentDataQuery | GetSaveIntentDataWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

package/dist/storefront-api/load-selected-variant.d.ts

@@ -1,16 +1,14 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
+import type { SelectedOptionInput } from "./types/storefront.types";
 import type { GetSelectedVariantQuery } from "./types/storefront.generated";
-import type { CountryCode, LanguageCode, SelectedOptionInput } from "./types/storefront.types";
 export type LoadSelectedVariantResponse = StorefrontApiResponse<GetSelectedVariantQuery>;
 export type { GetSelectedVariantQueryVariables } from "./types/storefront.generated";
 export interface LoadSelectedVariantArgs {
     productId?: string;
     productHandle?: string;
     selectedOptions: SelectedOptionInput[];
-    country: CountryCode;
-    language: LanguageCode;
 }
-export declare const loadSelectedVariant: (client: StorefrontApiClient, { productId, productHandle, selectedOptions, country, language, }: LoadSelectedVariantArgs) => Promise<{
+export declare const loadSelectedVariant: (client: StorefrontApiClient, { productId, productHandle, selectedOptions }: LoadSelectedVariantArgs) => Promise<{
     data: GetSelectedVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

package/dist/storefront-api/storefront-api-client.d.ts

@@ -7,7 +7,6 @@ import { LoadProductOptionsArgs } from "./load-product-options";
 import { LoadProductRecommendationsArgs } from "./load-product-recommendations";
 import { LoadSaveIntentDataArgs } from "./load-save-intent-data";
 import { LoadSelectedVariantArgs } from "./load-selected-variant";
-import { StorefrontContext } from "../types";
 export * from "./load-product-card-data";
 export * from "./load-product-options";
 export * from "./load-product-recommendations";
@@ -18,7 +17,7 @@ export interface StorefrontApiResponse<TData> {
     errors: ResponseErrors;
 }
 export declare const API_VERSION = "2025-07";
-export interface StorefrontApiOptions {
+export interface StorefrontConfig {
     storeDomain: string;
     accessToken: string;
 }
@@ -26,38 +25,36 @@ export declare class StorefrontApiClient {
     private client;
     private readonly shortCache;
     private readonly longCache;
-    private readonly options;
-    private readonly context;
-    constructor(options: StorefrontApiOptions, context: StorefrontContext);
+    constructor(config: StorefrontConfig);
     fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
     query: <TData, TVariables extends Record<string, unknown>>(query: string, variables: TVariables) => Promise<{
         data: (TData extends undefined ? any : TData) | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductOptions: (args: Omit<LoadProductOptionsArgs, "country" | "language">) => Promise<{
+    loadProductOptions: (args: LoadProductOptionsArgs) => Promise<{
         data: import("./storefront-api-client").GetProductOptionsQuery | import("./storefront-api-client").GetProductOptionsWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSelectedVariant: (args: Omit<LoadSelectedVariantArgs, "country" | "language">) => Promise<{
+    loadSelectedVariant: (args: LoadSelectedVariantArgs) => Promise<{
         data: import("./storefront-api-client").GetSelectedVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductCardData: (args: Omit<LoadProductCardDataArgs, "country" | "language">) => Promise<{
+    loadProductCardData: (args: LoadProductCardDataArgs) => Promise<{
         data: import("./storefront-api-client").GetProductCardDataQuery | import("./storefront-api-client").GetProductCardDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductDetailData: (args: Omit<LoadProductDetailDataArgs, "country" | "language">) => Promise<{
+    loadProductDetailData: (args: LoadProductDetailDataArgs) => Promise<{
         data: import("./storefront-api-client").GetProductDetailDataQuery | import("./storefront-api-client").GetProductDetailDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductImages: (args: Omit<LoadProductImagesArgs, "country" | "language">) => Promise<{
+    loadProductImages: (args: LoadProductImagesArgs) => Promise<{
         data: (Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash"> | undefined)[];
         error: null;
     } | {
         data: null;
         error: Error;
     }>;
-    loadProductRecommendations: (args: Omit<LoadProductRecommendationsArgs, "country" | "language">) => Promise<{
+    loadProductRecommendations: (args: LoadProductRecommendationsArgs) => Promise<{
         data: {
             productRecommendations?: import("./types/storefront.types").Product[] | null;
         } | undefined;
@@ -67,7 +64,7 @@ export declare class StorefrontApiClient {
         data: import("./storefront-api-client").GetProductIdByHandleQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSaveIntentData: (args: Omit<LoadSaveIntentDataArgs, "country" | "language">) => Promise<{
+    loadSaveIntentData: (args: LoadSaveIntentDataArgs) => Promise<{
         data: import("./storefront-api-client").GetSaveIntentDataQuery | import("./storefront-api-client").GetSaveIntentDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;

package/dist/swish-api/swish-api-client.d.ts

@@ -1,7 +1,13 @@
-import { ApiResponse, Item, ItemControllerFindData, ItemDetail, ListControllerFindData, ListDetail, PaginatedApiResponse, SwishClientConfig } from "@swishapp/api-client";
+import { ApiResponse, Item, ItemControllerFindData, ItemDetail, ListControllerFindData, ListDetail, PaginatedApiResponse, SwishClientConfig, OrderDto, OrdersControllerFindData, OrderDetailDto } from "@swishapp/api-client";
 export interface SwishApiConfig extends SwishClientConfig {
     proxyMode?: boolean;
     customerId?: string;
+    loadProfile?: () => string | undefined;
+    storeProfile?: (profile: string) => void;
+    deleteProfile?: () => void;
+    loadAuthToken?: () => string | undefined;
+    storeAuthToken?: (token: string) => void;
+    deleteAuthToken?: () => void;
     responseInterceptor?: (response: Response, request: Request) => Promise<void> | void;
 }
 export declare class SwishApi {
@@ -35,6 +41,10 @@ export declare class SwishApi {
         addItemsToList: (listId: string, itemIds: import("@swishapp/api-client").AddItemsToListInput["itemIds"]) => Promise<ApiResponse<ListDetail>>;
         removeItemFromList: (listId: string, itemId: string) => Promise<ApiResponse<unknown>>;
     };
+    get orders(): {
+        list: (query?: OrdersControllerFindData["query"]) => Promise<PaginatedApiResponse<OrderDto>>;
+        findById: (orderId: number) => Promise<ApiResponse<OrderDetailDto>>;
+    };
     get profiles(): {
         customerAccountsVersion: () => Promise<ApiResponse<import("@swishapp/api-client").AccountsVersionResult>>;
         createToken: (body?: import("@swishapp/api-client").CreateProfileTokenInput, options?: {

package/dist/swish-ui/swish-ui-element.d.ts

@@ -1,11 +1,9 @@
 export interface Ref<T> {
     current: T;
 }
-declare const BaseElement: typeof HTMLElement;
-export declare class SwishUiElement extends BaseElement {
+export declare class SwishUiElement extends HTMLElement {
     constructor();
     private componentRef;
     getComponentRef: <TComponent = unknown>() => Ref<TComponent>;
     setComponentRef: <TComponent = unknown>(ref: Ref<TComponent>) => void;
 }
-export {};

package/dist/swish-ui/swish-ui-utils.d.ts

@@ -1,4 +1,4 @@
-import type { StorefrontContext, SwishUiManifest, SwishUiOptions } from "../types";
+import type { SwishUiManifest, SwishUiOptions } from "../types";
 import type { ShopBridge } from "../utils/shop-bridge";
 import type { Ref, SwishUiElement } from "./swish-ui-element";
 import { Item, ItemDetail, List } from "@swishapp/api-client";
@@ -19,7 +19,7 @@ export interface Toast {
         onClick?: () => void;
     };
 }
-export declare const setConfig: (context: StorefrontContext, uiOptions?: SwishUiOptions) => void;
+export declare const setConfig: (opts: SwishUiOptions) => void;
 export declare const hideModal: (element: string | HTMLElement) => Promise<void>;
 export declare const showModal: (element: string | HTMLElement) => Promise<void>;
 export interface SignInOptions {

package/dist/swish.d.ts

@@ -1,4 +1,4 @@
-import type { SwishOptions } from "./types";
+import type { SwishAppOptions, SwishEmbedData } from "./types";
 import { AjaxApiClient } from "./ajax-api/ajax-api-client";
 import { createElementLocator, createLocationObserver } from "./dom/dom-utils";
 import { EventBus } from "./events/event-bus";
@@ -7,7 +7,8 @@ import { computed, effect, signal } from "./state";
 import { StorefrontApiClient } from "./storefront-api/storefront-api-client";
 import { SwishApi } from "./swish-api/swish-api-client";
 export declare const VERSION: string;
-export declare const createSwish: (options: SwishOptions) => Promise<SwishApp>;
+export declare const swishEmbedData: SwishEmbedData;
+export declare const swishApp: (options: SwishAppOptions) => Promise<SwishApp>;
 export declare class SwishApp {
     private readonly swishApi;
     private readonly swishApiPublisher;
@@ -17,7 +18,7 @@ export declare class SwishApp {
     private readonly options;
     readonly events: EventBus;
     readonly intents: Intents;
-    constructor(options: SwishOptions);
+    constructor(options: SwishAppOptions);
     get customer(): {
         id: string | null;
         email: string | null;
@@ -26,11 +27,11 @@ export declare class SwishApp {
         b2b: boolean | null;
     };
     get localization(): {
-        country: import("./storefront-api/types/storefront.types").CountryCode;
-        language: import("./storefront-api/types/storefront.types").LanguageCode;
-        market: string;
+        country: string;
+        language: string;
+        market: number;
     };
-    get routes(): {
+    get shopifyRoutes(): {
         accountUrl: string;
         accountLoginUrl: string;
         rootUrl: string;
@@ -44,8 +45,8 @@ export declare class SwishApp {
         showModal: (element: string | HTMLElement) => Promise<void>;
         initShopBridge: ({ onShopModalOpen, }: {
             onShopModalOpen: () => void;
-        }) => Promise<import("./swish").ShopBridge>;
-        showToast: (toast: import("./swish").Toast) => Promise<void>;
+        }) => Promise<import(".").ShopBridge>;
+        showToast: (toast: import(".").Toast) => Promise<void>;
         initListDetailPage: (options: import("./swish-ui/swish-ui-utils").ListDetailPageOptions, refElement: HTMLElement) => Promise<void>;
     };
     readonly dom: {
@@ -74,10 +75,10 @@ export declare class SwishApp {
             loading: boolean;
             error: import("@swishapp/api-client").ApiError | null;
         }>;
-        swishQuery: <TResponse extends import("@swishapp/api-client").ApiResponse<any> | import("@swishapp/api-client").PaginatedApiResponse<any>, TVariables>(fetch: import("./state").FetchFn<TResponse, TVariables>, options?: {
+        swishQuery: <TResponse extends import("@swishapp/api-client").ApiResponse<any> | import("@swishapp/api-client").PaginatedApiResponse<any>, TVariables>(fetch: import("./state/swish-query-signals").FetchFn<TResponse, TVariables>, options?: {
             variables?: import("@preact/signals-core").Signal<TVariables>;
             skip?: import("@preact/signals-core").Signal<boolean>;
-            refetch?: import("./swish").EventName[];
+            refetch?: import(".").EventName[];
         }) => {
             data: import("@preact/signals-core").Signal<(TResponse extends {
                 data: infer D;
@@ -92,12 +93,3 @@ export declare class SwishApp {
         computed: typeof computed;
     };
 }
-export type * from "./types";
-export type * from "@swishapp/api-client";
-export type * from "./ajax-api/ajax-api-client";
-export type { EventName } from "./events/event-bus";
-export type * from "./storefront-api/storefront-api-client";
-export type * from "./intents/types";
-export type { Ref, SwishUiElement } from "./swish-ui/swish-ui-element";
-export type { Toast, ToastManager, UnsaveAlertSubmitData, ListSelectSubmitData, VariantSelectSubmitData, UnsaveAlertOptions, ListSelectOptions, VariantSelectOptions, QuickBuySubmitData, QuickBuyOptions, } from "./swish-ui/swish-ui-utils";
-export type { ShopBridge } from "./utils/shop-bridge";