@swishapp/sdk 0.61.0 → 0.71.0

package/dist/intents/handlers/open-quick-buy-handler.d.ts

@@ -1,5 +1,5 @@
 import * as v from "valibot";
-import { QuickBuySubmitData } from "../../swish-ui/swish-ui-utils";
+import { QuickBuySubmitData } from "../../swish";
 import { IntentHandler } from "../intent-handler";
 import { IntentBase, IntentResponse, SuccessIntentResponse } from "../types";
 export declare const OpenQuickBuyIntentDataSchema: v.ObjectSchema<{

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

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

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

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

package/dist/intents/intents.d.ts

@@ -1,16 +1,26 @@
 import { SwishApp } from "../swish";
 import { Intent, IntentActivity, IntentQuery, IntentQueryWithParams, IntentResponse } from "./types";
+import { SwishUi } from "../swish-ui/swish-ui";
 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 declare class Intents {
     private readonly swish;
+    private readonly ui;
     private readonly eventBus;
     private readonly options;
-    constructor(swish: SwishApp, options: IntentOptions);
+    constructor(swish: SwishApp, ui: SwishUi);
     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/options/swish-options.d.ts

@@ -0,0 +1,14 @@
+import { StorefrontApiOptions, SwishClientConfig } from "../swish";
+import { StorefrontContext, SwishBadgeOptions, SwishMetafieldOptions, SwishOptions, SwishProxyOptions, SwishUiOptions } from "./types";
+export type SwishOptionsInput = {
+    proxy?: SwishProxyOptions;
+    storefrontApi: StorefrontApiOptions;
+    storefrontContext: StorefrontContext;
+    badges?: SwishBadgeOptions;
+    metafields?: SwishMetafieldOptions;
+    swishApi?: SwishClientConfig & {
+        version: string;
+    };
+    swishUi?: SwishUiOptions;
+};
+export declare const createSwishOptions: (options: SwishOptionsInput) => SwishOptions;

package/dist/options/types.d.ts

@@ -0,0 +1,118 @@
+import { IntentOptions } from "../intents/intents";
+import { CountryCode, LanguageCode } from "../storefront-api/types/storefront.types";
+import { GetProductCardDataQuery, GetProductCardDataWithVariantQuery, StorefrontApiOptions, SwishClientConfig } from "../swish";
+import { Badge } from "../utils/shopify-badge-utils";
+export interface SwishOptions {
+    proxy: SwishProxyOptions;
+    storefrontApi: StorefrontApiOptions;
+    storefrontContext: StorefrontContext;
+    badges: SwishBadgeOptions;
+    metafields: SwishMetafieldOptions;
+    swishApi: SwishClientConfig & {
+        version: string;
+    };
+    swishUi: SwishUiOptions;
+}
+export interface SwishMetafieldOptions {
+    product: `${string}.${string}`[];
+    productVariant: `${string}.${string}`[];
+}
+export interface SwishBadgeOptions {
+    getBadges: (args: {
+        product: GetProductCardDataQuery["product"];
+        variant?: GetProductCardDataWithVariantQuery["variant"];
+        defaultBadges: string[];
+    }) => (string | Badge)[];
+}
+export interface SwishProxyOptions {
+    baseUrl: string;
+}
+export interface SwishUiOptions {
+    baseUrl: string;
+    components: SwishComponentOptions;
+    css: (string | URL)[];
+    intents: IntentOptions;
+    theme: Record<string, string>;
+    version: string;
+}
+export interface StorefrontContext {
+    customer: {
+        id: string | null;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        b2b: boolean | null;
+    };
+    localization: {
+        country: CountryCode;
+        language: LanguageCode;
+        market: string;
+    };
+    routes: {
+        accountUrl: string;
+        accountLoginUrl: string;
+        rootUrl: string;
+    };
+}
+export interface SwishComponentOptions {
+    productRow: SwishProductRowOptions;
+    productDetail: SwishProductDetailOptions;
+    variantSelect: SwishVariantSelectOptions;
+    imageSlider: SwishImageSliderOptions;
+    images: SwishImageOptions;
+    buyButtons: SwishBuyButtonsOptions;
+    drawer: SwishDrawerOptions;
+    listDetailPage: SwishListDetailPageOptions;
+}
+export interface SwishListDetailPageOptions {
+    desktopColumns: number;
+    showBuyButton: boolean;
+}
+export interface SwishProductRowOptions {
+    showVariantTitle: boolean;
+}
+export interface SwishProductDetailOptions {
+    /** Clamp the description to this many lines in the UI. */
+    descriptionMaxLines: number;
+}
+export type SwishVariantSelectDisplay = "pills" | "rows";
+export interface SwishVariantSelectOptions {
+    displayType: SwishVariantSelectDisplay;
+}
+export interface SwishImageSliderOptions {
+    flush: boolean;
+    loop: boolean;
+}
+export interface SwishBuyButtonsOptions {
+    shopPay: boolean;
+}
+export interface SwishImageOptions {
+    baseTint: boolean;
+}
+export type SwishDrawerNavigationVariant = "floating" | "docked";
+export interface SwishDrawerNavigationItem {
+    id: string;
+    enabled: boolean;
+    href: string;
+}
+export interface SwishDrawerNavigationOptions {
+    variant: SwishDrawerNavigationVariant;
+    items: SwishDrawerNavigationItem[];
+}
+export interface SwishDrawerMiniMenuItem {
+    title: string;
+    url: string;
+}
+export interface SwishDrawerMiniMenuOptions {
+    items: SwishDrawerMiniMenuItem[];
+}
+export interface SwishDrawerLogoOptions {
+    url: string;
+    altText: string;
+}
+export interface SwishDrawerOptions {
+    title: string;
+    logo: SwishDrawerLogoOptions;
+    navigation: SwishDrawerNavigationOptions;
+    miniMenu: SwishDrawerMiniMenuOptions;
+}

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,8 @@ 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 { ShopifyBadgesUtils } from "../utils/shopify-badge-utils";
+import { StorefrontContext, SwishMetafieldOptions } from "../options/types";
 export * from "./load-product-card-data";
 export * from "./load-product-options";
 export * from "./load-product-recommendations";
@@ -16,8 +18,8 @@ export interface StorefrontApiResponse<TData> {
     data: TData;
     errors: ResponseErrors;
 }
-export declare const API_VERSION = "2025-07";
-export interface StorefrontConfig {
+export declare const API_VERSION = "2025-10";
+export interface StorefrontApiOptions {
     storeDomain: string;
     accessToken: string;
 }
@@ -25,48 +27,156 @@ export declare class StorefrontApiClient {
     private client;
     private readonly shortCache;
     private readonly longCache;
-    constructor(config: StorefrontConfig);
+    private readonly options;
+    private readonly context;
+    private readonly metafields;
+    private readonly badges;
+    constructor(options: StorefrontApiOptions, context: StorefrontContext, badges: ShopifyBadgesUtils, metafields?: SwishMetafieldOptions);
     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: ArgsWithoutDefaults<LoadProductOptionsArgs>) => Promise<{
         data: import("./storefront-api-client").GetProductOptionsQuery | import("./storefront-api-client").GetProductOptionsWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSelectedVariant: (args: LoadSelectedVariantArgs) => Promise<{
+    loadSelectedVariant: (args: ArgsWithoutDefaults<LoadSelectedVariantArgs>) => Promise<{
         data: import("./storefront-api-client").GetSelectedVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadProductCardData: (args: LoadProductCardDataArgs) => Promise<{
+    loadProductCardData: (args: ArgsWithoutDefaults<LoadProductCardDataArgs>) => Promise<{
         data: import("./storefront-api-client").GetProductCardDataQuery | import("./storefront-api-client").GetProductCardDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
+    } | {
+        data: {
+            badges: import("../utils/shopify-badge-utils").Badge[];
+            product?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").Product, "id" | "availableForSale" | "isGiftCard" | "onlineStoreUrl" | "description" | "descriptionHtml" | "handle" | "productType" | "tags" | "title"> & {
+                category?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").TaxonomyCategory, "id" | "name">>;
+                compareAtPriceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                featuredImage?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                priceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                variantsCount?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Count, "count">>;
+                metafields: Array<import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Metafield, "key" | "namespace" | "value">>>;
+            })>;
+            variant?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").ProductVariant, "id" | "availableForSale" | "currentlyNotInStock" | "sku" | "title"> & {
+                compareAtPrice?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">>;
+                image?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                price: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                selectedOptions: Array<Pick<import("./types/storefront.types").SelectedOption, "name" | "value">>;
+                metafields: Array<import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Metafield, "key" | "namespace" | "value">>>;
+            })>;
+        };
+        errors: ResponseErrors | null;
     }>;
-    loadProductDetailData: (args: LoadProductDetailDataArgs) => Promise<{
+    loadProductDetailData: (args: ArgsWithoutDefaults<LoadProductDetailDataArgs>) => Promise<{
         data: import("./storefront-api-client").GetProductDetailDataQuery | import("./storefront-api-client").GetProductDetailDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
+    } | {
+        data: {
+            product: (Pick<import("./types/storefront.types").Product, "title" | "id" | "availableForSale" | "handle" | "onlineStoreUrl" | "description" | "descriptionHtml" | "encodedVariantAvailability" | "encodedVariantExistence" | "isGiftCard" | "productType" | "tags"> & {
+                category?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").TaxonomyCategory, "id" | "name">>;
+                compareAtPriceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                featuredImage?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                priceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                variantsCount?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Count, "count" | "precision">>;
+                metafields: Array<import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Metafield, "key" | "namespace" | "value">>>;
+                options: Array<(Pick<import("./types/storefront.types").ProductOption, "id" | "name"> & {
+                    optionValues: Array<(Pick<import("./types/storefront.types").ProductOptionValue, "name"> & {
+                        swatch?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").ProductOptionValueSwatch, "color"> & {
+                            image?: import("./types/storefront.types").Maybe<{
+                                previewImage?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "url">>;
+                            }>;
+                        })>;
+                        firstSelectableVariant?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").ProductVariant, "id"> & {
+                            image?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                        })>;
+                    })>;
+                })>;
+                images: {
+                    nodes: Array<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                };
+            }) | (Pick<import("./types/storefront.types").Product, "title" | "id" | "availableForSale" | "handle" | "onlineStoreUrl" | "description" | "descriptionHtml" | "encodedVariantAvailability" | "encodedVariantExistence" | "isGiftCard" | "productType" | "tags"> & {
+                category?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").TaxonomyCategory, "id" | "name">>;
+                compareAtPriceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                featuredImage?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                priceRange: {
+                    maxVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                    minVariantPrice: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                };
+                variantsCount?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Count, "count" | "precision">>;
+                metafields: Array<import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Metafield, "key" | "namespace" | "value">>>;
+                options: Array<(Pick<import("./types/storefront.types").ProductOption, "id" | "name"> & {
+                    optionValues: Array<(Pick<import("./types/storefront.types").ProductOptionValue, "name"> & {
+                        swatch?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").ProductOptionValueSwatch, "color"> & {
+                            image?: import("./types/storefront.types").Maybe<{
+                                previewImage?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "url">>;
+                            }>;
+                        })>;
+                        firstSelectableVariant?: import("./types/storefront.types").Maybe<(Pick<import("./types/storefront.types").ProductVariant, "id"> & {
+                            image?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                        })>;
+                    })>;
+                })>;
+                images: {
+                    nodes: Array<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                };
+            });
+            variant: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").ProductVariant, "title" | "id" | "availableForSale" | "currentlyNotInStock" | "sku"> & {
+                compareAtPrice?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">>;
+                image?: import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Image, "id" | "altText" | "url" | "thumbhash">>;
+                price: Pick<import("./types/storefront.types").MoneyV2, "amount" | "currencyCode">;
+                selectedOptions: Array<Pick<import("./types/storefront.types").SelectedOption, "name" | "value">>;
+                metafields: Array<import("./types/storefront.types").Maybe<Pick<import("./types/storefront.types").Metafield, "key" | "namespace" | "value">>>;
+            }> | undefined;
+            badges: import("../utils/shopify-badge-utils").Badge[];
+        };
+        errors: ResponseErrors | null;
     }>;
-    loadProductImages: (args: LoadProductImagesArgs) => Promise<{
+    loadProductImages: (args: ArgsWithoutDefaults<LoadProductImagesArgs>) => 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: ArgsWithoutDefaults<LoadProductRecommendationsArgs>) => Promise<{
         data: {
             productRecommendations?: import("./types/storefront.types").Product[] | null;
         } | undefined;
         errors: ResponseErrors | null;
+    } | {
+        data: {
+            productRecommendations: {
+                product: import("./types/storefront.types").Product;
+                badges: import("../utils/shopify-badge-utils").Badge[];
+            }[];
+        };
+        errors: ResponseErrors | null;
     }>;
     loadProductId: (args: LoadProductIdArgs) => Promise<{
         data: import("./storefront-api-client").GetProductIdByHandleQuery | undefined;
         errors: ResponseErrors | null;
     }>;
-    loadSaveIntentData: (args: LoadSaveIntentDataArgs) => Promise<{
+    loadSaveIntentData: (args: ArgsWithoutDefaults<LoadSaveIntentDataArgs>) => Promise<{
         data: import("./storefront-api-client").GetSaveIntentDataQuery | import("./storefront-api-client").GetSaveIntentDataWithVariantQuery | undefined;
         errors: ResponseErrors | null;
     }>;
     clearCache(): Promise<void>;
 }
+type ArgsWithoutDefaults<T> = Omit<T, "country" | "language" | "productMetafields" | "variantMetafields">;