@swishapp/sdk 0.58.0 → 0.60.0-beta.1

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

@@ -1,10 +1,10 @@
 import { SwishApp } from "../swish";
-import { IntentOptions } from "./intents";
+import { IntentOptionsWithDefaults } 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: IntentOptions;
-    constructor(swish: SwishApp, eventBus: IntentEventBus, options: IntentOptions);
+    protected readonly options: IntentOptionsWithDefaults;
+    constructor(swish: SwishApp, eventBus: IntentEventBus, options: IntentOptionsWithDefaults);
     abstract invoke(intent: T): Promise<IntentResponse<T>>;
 }

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

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

package/dist/intents/intents.d.ts

@@ -1,16 +1,30 @@
 import { SwishApp } from "../swish";
 import { Intent, IntentActivity, IntentQuery, IntentQueryWithParams, IntentResponse } from "./types";
 export interface IntentOptions {
-    allowSaveWithoutVariant?: boolean;
-    deleteSavedItemsWithoutEdit?: boolean;
-    showToastAfterSave?: boolean;
-    showToastAfterDelete?: boolean;
+    save?: {
+        requireVariant?: boolean;
+        showToast?: boolean;
+    };
+    edit?: {
+        showToast?: boolean;
+    };
+    unsave?: {
+        requireConfirmation?: boolean;
+        openEditor?: boolean;
+        showToast?: 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;
     getIntentQuery(intent: Pick<Intent, "action" | "type">): IntentQuery;

package/dist/state/index.d.ts

@@ -2,3 +2,4 @@ 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 { HasMetafieldsIdentifier } from "./types/storefront.types";
+import type { CountryCode, HasMetafieldsIdentifier, LanguageCode } from "./types/storefront.types";
 export type LoadProductCardDataResponse = StorefrontApiResponse<GetProductCardDataQuery | GetProductCardDataWithVariantQuery>;
 export type { GetProductCardDataQueryVariables } from "./types/storefront.generated";
 export interface LoadProductCardDataArgs {
@@ -8,8 +8,10 @@ export interface LoadProductCardDataArgs {
     variantId?: string;
     productMetafields?: HasMetafieldsIdentifier[];
     variantMetafields?: HasMetafieldsIdentifier[];
+    country: CountryCode;
+    language: LanguageCode;
 }
-export declare const loadProductCardData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, }: LoadProductCardDataArgs) => Promise<{
+export declare const loadProductCardData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, country, language, }: 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 { HasMetafieldsIdentifier } from "./types/storefront.types";
+import type { CountryCode, HasMetafieldsIdentifier, LanguageCode } from "./types/storefront.types";
 export type LoadProductDetailDataResponse = StorefrontApiResponse<GetProductDetailDataQuery | GetProductDetailDataWithVariantQuery>;
 export type { GetProductDetailDataQueryVariables } from "./types/storefront.generated";
 export interface LoadProductDetailDataArgs {
@@ -8,8 +8,10 @@ export interface LoadProductDetailDataArgs {
     variantId?: string;
     productMetafields?: HasMetafieldsIdentifier[];
     variantMetafields?: HasMetafieldsIdentifier[];
+    country: CountryCode;
+    language: LanguageCode;
 }
-export declare const loadProductDetailData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, }: LoadProductDetailDataArgs) => Promise<{
+export declare const loadProductDetailData: (client: StorefrontApiClient, { productId, variantId, productMetafields, variantMetafields, country, language, }: LoadProductDetailDataArgs) => Promise<{
     data: GetProductDetailDataQuery | GetProductDetailDataWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

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

@@ -1,4 +1,5 @@
 import { StorefrontApiClient, StorefrontApiResponse } from "./storefront-api-client";
+import type { CountryCode, LanguageCode } from "./types/storefront.types";
 export type LoadProductImagesResponse = StorefrontApiResponse<{
     id: string;
     altText: string;
@@ -10,8 +11,10 @@ export interface LoadProductImagesArgs {
         productId: number;
         variantId?: number | null;
     }[];
+    country: CountryCode;
+    language: LanguageCode;
 }
-export declare const loadProductImages: (client: StorefrontApiClient, { items }: LoadProductImagesArgs) => Promise<{
+export declare const loadProductImages: (client: StorefrontApiClient, { items, country, language }: 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,13 +1,16 @@
 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 }: LoadProductOptionsArgs) => Promise<{
+export declare const loadProductOptions: (client: StorefrontApiClient, { productId, productHandle, variantId, country, language, }: 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 { HasMetafieldsIdentifier, Product, ProductRecommendationIntent } from "./types/storefront.types";
+import type { CountryCode, HasMetafieldsIdentifier, LanguageCode, Product, ProductRecommendationIntent } from "./types/storefront.types";
 export type LoadProductRecommendationsResponse = StorefrontApiResponse<{
     productRecommendations?: Product[] | null;
 }>;
@@ -8,8 +8,10 @@ export interface LoadProductRecommendationsArgs {
     productHandle?: string;
     intent?: ProductRecommendationIntent;
     productMetafields?: HasMetafieldsIdentifier[];
+    country: CountryCode;
+    language: LanguageCode;
 }
-export declare const loadProductRecommendations: (client: StorefrontApiClient, { productId, productHandle, intent, productMetafields, }: LoadProductRecommendationsArgs) => Promise<{
+export declare const loadProductRecommendations: (client: StorefrontApiClient, { productId, productHandle, intent, productMetafields, country, language, }: LoadProductRecommendationsArgs) => Promise<{
     data: {
         productRecommendations?: Product[] | null;
     } | undefined;

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

@@ -1,12 +1,13 @@
 import { StorefrontApiClient } from "./storefront-api-client";
 import type { GetSaveIntentDataQuery, GetSaveIntentDataWithVariantQuery } from "./types/storefront.generated";
-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<{
+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<{
     data: GetSaveIntentDataQuery | GetSaveIntentDataWithVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

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

@@ -1,14 +1,16 @@
 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 }: LoadSelectedVariantArgs) => Promise<{
+export declare const loadSelectedVariant: (client: StorefrontApiClient, { productId, productHandle, selectedOptions, country, language, }: LoadSelectedVariantArgs) => Promise<{
     data: GetSelectedVariantQuery | undefined;
     errors: import("@shopify/graphql-client").ResponseErrors | null;
 }>;

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

@@ -7,6 +7,7 @@ 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";
@@ -17,7 +18,7 @@ export interface StorefrontApiResponse<TData> {
     errors: ResponseErrors;
 }
 export declare const API_VERSION = "2025-07";
-export interface StorefrontConfig {
+export interface StorefrontApiOptions {
     storeDomain: string;
     accessToken: string;
 }
@@ -25,36 +26,38 @@ export declare class StorefrontApiClient {
     private client;
     private readonly shortCache;
     private readonly longCache;
-    constructor(config: StorefrontConfig);
+    private readonly options;
+    private readonly context;
+    constructor(options: StorefrontApiOptions, context: StorefrontContext);
     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: LoadProductOptionsArgs) => Promise<{
+    loadProductOptions: (args: Omit<LoadProductOptionsArgs, "country" | "language">) => Promise<{
         data: import("./storefront-api-client").GetProductOptionsQuery | import("./storefront-api-client").GetProductOptionsWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSelectedVariant: (args: LoadSelectedVariantArgs) => Promise<{
+    loadSelectedVariant: (args: Omit<LoadSelectedVariantArgs, "country" | "language">) => Promise<{
         data: import("./storefront-api-client").GetSelectedVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductCardData: (args: LoadProductCardDataArgs) => Promise<{
+    loadProductCardData: (args: Omit<LoadProductCardDataArgs, "country" | "language">) => Promise<{
         data: import("./storefront-api-client").GetProductCardDataQuery | import("./storefront-api-client").GetProductCardDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductDetailData: (args: LoadProductDetailDataArgs) => Promise<{
+    loadProductDetailData: (args: Omit<LoadProductDetailDataArgs, "country" | "language">) => Promise<{
         data: import("./storefront-api-client").GetProductDetailDataQuery | import("./storefront-api-client").GetProductDetailDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductImages: (args: LoadProductImagesArgs) => Promise<{
+    loadProductImages: (args: Omit<LoadProductImagesArgs, "country" | "language">) => Promise<{
         data: (Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash"> | undefined)[];
         error: null;
     } | {
         data: null;
         error: Error;
     }>;
-    loadProductRecommendations: (args: LoadProductRecommendationsArgs) => Promise<{
+    loadProductRecommendations: (args: Omit<LoadProductRecommendationsArgs, "country" | "language">) => Promise<{
         data: {
             productRecommendations?: import("./types/storefront.types").Product[] | null;
         } | undefined;
@@ -64,7 +67,7 @@ export declare class StorefrontApiClient {
         data: import("./storefront-api-client").GetProductIdByHandleQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSaveIntentData: (args: LoadSaveIntentDataArgs) => Promise<{
+    loadSaveIntentData: (args: Omit<LoadSaveIntentDataArgs, "country" | "language">) => 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,8 +1,7 @@
 import { ApiResponse, Item, ItemControllerFindData, ItemDetail, ListControllerFindData, ListDetail, PaginatedApiResponse, SwishClientConfig } from "@swishapp/api-client";
 export interface SwishApiConfig extends SwishClientConfig {
-    loadProfile?: () => string | undefined;
-    storeProfile?: (profile: string) => void;
-    deleteProfile?: () => void;
+    proxyMode?: boolean;
+    customerId?: string;
     responseInterceptor?: (response: Response, request: Request) => Promise<void> | void;
 }
 export declare class SwishApi {
@@ -11,6 +10,8 @@ export declare class SwishApi {
     private readonly config;
     private readonly itemsLoader;
     constructor(config: SwishApiConfig, cacheKeyPrefix: string);
+    private _bootstrapAuthPromise?;
+    bootstrapAuth(): Promise<void>;
     private processProfileHeader;
     get items(): {
         list: (query?: ItemControllerFindData["query"], options?: {
@@ -36,7 +37,9 @@ export declare class SwishApi {
     };
     get profiles(): {
         customerAccountsVersion: () => Promise<ApiResponse<import("@swishapp/api-client").AccountsVersionResult>>;
-        createToken: (body?: import("@swishapp/api-client").CreateProfileTokenInput) => Promise<ApiResponse<import("@swishapp/api-client").CreateProfileTokenResult>>;
+        createToken: (body?: import("@swishapp/api-client").CreateProfileTokenInput, options?: {
+            useProxy?: boolean;
+        }) => Promise<ApiResponse<import("@swishapp/api-client").CreateProfileTokenResult>>;
         identify: (body: import("@swishapp/api-client").IdentifyProfileInput) => Promise<ApiResponse<import("@swishapp/api-client").IdentifyProfileResult>>;
     };
     clearCache(): Promise<void>;

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

@@ -1,9 +1,11 @@
 export interface Ref<T> {
     current: T;
 }
-export declare class SwishUiElement extends HTMLElement {
+declare const BaseElement: typeof HTMLElement;
+export declare class SwishUiElement extends BaseElement {
     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 { SwishUiManifest, SwishUiOptions } from "../types";
+import type { StorefrontContext, 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: (opts: SwishUiOptions) => void;
+export declare const setConfig: (context: StorefrontContext, uiOptions?: SwishUiOptions) => void;
 export declare const hideModal: (element: string | HTMLElement) => Promise<void>;
 export declare const showModal: (element: string | HTMLElement) => Promise<void>;
 export interface SignInOptions {
@@ -67,6 +67,10 @@ export interface ListSelectSubmitData {
     variant?: ListSelectVariant;
 }
 export declare const showListSelect: (options: ListSelectOptions) => Promise<void>;
+export interface ListDetailPageOptions {
+    listId?: string;
+}
+export declare const initListDetailPage: (options: ListDetailPageOptions, refElement: HTMLElement) => Promise<void>;
 export declare const showToast: (toast: Toast) => Promise<void>;
 export declare const hideAllToasts: () => Promise<void>;
 export interface VariantSelectOptions {
@@ -115,6 +119,7 @@ export interface RequireUiComponentOptions<TComponent> {
     instance?: string;
     listeners?: Record<string, (event: Event | CustomEvent) => void>;
     onHydrated?: (ref: Ref<TComponent>) => void;
+    refElement?: HTMLElement;
 }
 export declare const requireUiComponent: <TComponent = unknown>(name: string, options?: RequireUiComponentOptions<TComponent>) => Promise<SwishUiElement>;
 export declare const insertComponent: <T extends HTMLElement = SwishUiElement>({ name, instance, template, position, refElement, }: {

package/dist/swish.d.ts

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