@commerce-blocks/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1009 @@
+import { batch } from '@preact/signals-core';
+import { computed } from '@preact/signals-core';
+import { effect } from '@preact/signals-core';
+import { ReadonlySignal } from '@preact/signals-core';
+import { Signal } from '@preact/signals-core';
+import { signal } from '@preact/signals-core';
+
+export declare function and(...expressions: (FilterExpression | FilterGroup)[]): FilterGroup;
+
+export declare interface ApiError {
+    readonly _tag: 'ApiError';
+    readonly code: ApiErrorCode;
+    readonly source: ApiSource;
+    readonly message: string;
+    readonly timestamp: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly request?: RequestContext;
+    readonly response?: ResponseContext;
+    readonly cause?: unknown;
+    readonly details?: {
+        readonly graphqlErrors?: GraphQLErrorDetail[];
+        readonly requestId?: string;
+        readonly shop?: string;
+    };
+}
+
+declare type ApiErrorCode = 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'RATE_LIMITED' | 'SERVICE_UNAVAILABLE' | 'GRAPHQL_ERROR' | 'PARSE_ERROR' | 'UNKNOWN';
+
+declare type ApiSource = 'layers' | 'shopify';
+
+export declare interface AutocompleteController {
+    execute: (query: string) => void;
+    state: ReadonlySignal<QueryState<PredictiveSearchResponse>>;
+    dispose: () => void;
+}
+
+export declare interface AutocompleteOptions {
+    debounceMs?: number;
+    signal?: AbortSignal;
+}
+
+declare interface BaseProduct {
+    id: ID;
+    gid: ProductGID;
+    numericId: number;
+    title: string;
+    handle: string;
+    type: string;
+    vendor: string;
+    description: string;
+    availableForSale: boolean;
+    images: Image_2[];
+    priceRange: {
+        min: Price;
+        max: Price;
+    };
+    compareAtPriceRange?: {
+        min: Price;
+        max: Price;
+    };
+    options: RichProductOption[];
+    tags: string[];
+    variants: ProductVariant[];
+    selectedOptions: ProductOption[];
+    metafields: Record<string, Record<string, unknown>> | unknown[];
+    calculated?: Record<string, unknown>;
+    isGiftCard: boolean;
+    onlineStoreUrl: string | null;
+    totalInventory: number;
+}
+
+export { batch }
+
+declare interface BlocksContext {
+    productsInCart?: {
+        productId: string;
+        variantId?: string;
+        quantity?: number;
+    }[];
+    geo?: {
+        country?: string;
+        province?: string;
+        city?: string;
+    };
+    custom?: Record<string, unknown>;
+}
+
+export declare interface BlocksController<P extends Product = Product> {
+    state: ReadonlySignal<QueryState<BlocksResult<P>>>;
+    execute: (query?: BlocksExecuteQuery) => Promise<Result<BlocksResult<P>, SdkError>>;
+    dispose: () => void;
+}
+
+export declare interface BlocksExecuteQuery {
+    page?: number;
+    limit?: number;
+    filters?: unknown;
+    signal?: AbortSignal;
+    discountEntitlements?: DiscountEntitlement[];
+    context?: BlocksContext;
+}
+
+export declare type BlocksExtender<P extends Product = Product> = (result: BlocksResult<P>, raw: LayersResponse & {
+    block?: BlocksInfo;
+}) => BlocksResult<P>;
+
+declare interface BlocksInfo {
+    id: string;
+    title: string;
+    anchor_type: 'product' | 'collection' | 'cart' | 'none';
+    strategy_type: 'interaction' | 'similar_products' | 'manual';
+    strategy_key: string;
+}
+
+export declare interface BlocksOptions {
+    blockId: string;
+    anchorId?: string;
+    anchorHandle?: string;
+}
+
+export declare interface BlocksResult<P extends Product = Product> extends LayersPagination {
+    products: P[];
+    facets: Record<string, Record<string, number>>;
+    _meta?: LayersMeta;
+    block?: BlocksInfo;
+}
+
+export declare interface CollectionController<P extends Product = Product> {
+    state: ReadonlySignal<QueryState<CollectionResult<P>>>;
+    execute: (query?: CollectionExecuteQuery) => Promise<Result<CollectionResult<P>, SdkError>>;
+    dispose: () => void;
+}
+
+export declare interface CollectionExecuteQuery {
+    page?: number;
+    limit?: number;
+    filters?: unknown;
+    sortOrderCode?: string;
+    signal?: AbortSignal;
+    includeMeta?: boolean;
+    collectionMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    includeFilters?: boolean;
+}
+
+export declare type CollectionExtender<P extends Product = Product> = (result: CollectionResult<P>, raw: LayersResponse) => CollectionResult<P>;
+
+declare interface CollectionMeta {
+    handle: string;
+    title?: string;
+    description?: string;
+    descriptionHtml?: string;
+    image?: {
+        url: string;
+        alt?: string;
+        width?: number;
+        height?: number;
+    };
+    metafields?: (MetafieldResult_2 | null)[];
+    totalProducts: number;
+    totalPages: number;
+    lastPageFetched: number;
+    facets?: Record<string, Record<string, number>>;
+    lastFetched: number;
+}
+
+export declare interface CollectionOptions {
+    handle: string;
+    defaultSort?: string;
+}
+
+export declare interface CollectionResult<P extends Product = Product> extends LayersPagination {
+    products: P[];
+    facets: Record<string, Record<string, number>>;
+    _meta?: LayersMeta;
+    collection?: ShopifyCollection;
+}
+
+declare type CommerceBlocksID = `${CommerceBlocksType}-${OptionSegment}` | `${CommerceBlocksType}-${OptionSegment}-${OptionSegment}` | `${CommerceBlocksType}-${OptionSegment}-${OptionSegment}-${OptionSegment}`;
+
+declare type CommerceBlocksType = 'Product' | 'ProductVariant';
+
+export { computed }
+
+export declare interface ConfigError {
+    readonly _tag: 'ConfigError';
+    readonly code: ConfigErrorCode;
+    readonly message: string;
+    readonly timestamp: string;
+    readonly field: string;
+    readonly value?: unknown;
+    readonly expected?: string;
+}
+
+declare type ConfigErrorCode = 'MISSING_CONFIG' | 'INVALID_CONFIG';
+
+export declare function createSdk<P extends Product = Product>(config: SdkConfig<P>): Result<Sdk<P>, ConfigError>;
+
+declare type CustomFetch = (url: string, init?: RequestInit) => Promise<Response>;
+
+declare interface DiscountEntitlement {
+    entitled: {
+        all?: boolean;
+        products?: string[];
+        variants?: (string | number)[];
+        collections?: string[];
+    };
+    discount: {
+        type: 'PERCENTAGE' | 'FIXED_AMOUNT';
+        value: number;
+    };
+}
+
+export { effect }
+
+declare interface Entry<T> {
+    data: T;
+    timestamp: number;
+}
+
+export declare function eq(property: string, value: FilterValue): FilterExpression;
+
+export declare function exists(property: string): FilterExpression;
+
+declare interface FeaturedMedia {
+    mediaContentType?: string;
+    alt: string;
+    src: string;
+    width: number;
+    height: number;
+}
+
+export declare function filter(expression: FilterExpression | FilterGroup): FilterGroupParam;
+
+declare enum FilterConditional {
+    And = "AND",
+    Or = "OR"
+}
+
+export declare interface FilterExpression {
+    property: string;
+    operator: FilterOperator;
+    values: (string | number | boolean)[];
+}
+
+export declare interface FilterGroup {
+    conditional: FilterConditional;
+    expressions: (FilterExpression | FilterGroup)[];
+}
+
+declare interface FilterGroupParam {
+    filter_group: FilterGroup;
+}
+
+export declare type FilterMap = Record<string, FilterMapEntry>;
+
+export declare type FilterMapEntry = string | {
+    property: string;
+    values?: Record<string, string>;
+};
+
+declare enum FilterOperator {
+    Equal = "eq",
+    NotEqual = "not_eq",
+    In = "in",
+    NotIn = "not_in",
+    GreaterThan = "gt",
+    GreaterThanOrEqual = "gte",
+    LessThan = "lt",
+    LessThanOrEqual = "lte",
+    Exists = "exists",
+    NotExists = "not_exists"
+}
+
+declare interface FilterResult {
+    id: string;
+    label: string;
+    type: 'LIST' | 'PRICE_RANGE' | 'BOOLEAN';
+    values: FilterValueResult[];
+}
+
+export declare type FilterTransformer = (filters: unknown) => FilterGroup | undefined;
+
+declare type FilterValue = string | number | boolean;
+
+declare interface FilterValueResult {
+    id: string;
+    label: string;
+    count: number;
+    input: string;
+}
+
+export declare function getSdk(): Result<Sdk, ConfigError>;
+
+declare interface GraphQLErrorDetail {
+    readonly message: string;
+    readonly locations?: {
+        line: number;
+        column: number;
+    }[];
+    readonly path?: (string | number)[];
+    readonly extensions?: Record<string, unknown>;
+}
+
+export declare function gt(property: string, value: number): FilterExpression;
+
+export declare function gte(property: string, value: number): FilterExpression;
+
+/**
+ * Minimal SDK Error Types
+ *
+ * 4 error types cover all scenarios:
+ * - NetworkError: Connection failed before response
+ * - ApiError: API returned an error response
+ * - ValidationError: Pre-request validation failed
+ * - ConfigError: SDK misconfigured
+ */
+declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+declare type ID = CommerceBlocksID;
+
+declare interface Image_2 {
+    url: string;
+    alt: string;
+    width: number;
+    height: number;
+}
+export { Image_2 as Image }
+
+declare interface ImageResult {
+    url: string;
+    altText: string | null;
+    width: number;
+    height: number;
+}
+
+export declare interface ImageSearchOptions {
+    imageId: string;
+    page?: number;
+    limit?: number;
+    filters?: unknown;
+    tuning?: LayersTuning;
+    signal?: AbortSignal;
+}
+
+export declare function inValues(property: string, values: FilterValue[]): FilterExpression;
+
+export declare function isInitialized(): boolean;
+
+export declare function isRetryable(error: SdkError): boolean;
+
+export declare function isSdkError(error: unknown): error is SdkError;
+
+declare interface LayersClientConfig extends LayersFetchConfig {
+    sorts: Sort[];
+    facets: string[];
+    attributes?: string[];
+}
+
+declare interface LayersFacets {
+    facets?: Record<string, Record<string, number>>;
+    facetRanges?: Record<string, {
+        min: number;
+        max: number;
+    }>;
+}
+
+declare interface LayersFetchConfig {
+    layersPublicToken: string;
+    layersBaseUrl?: string;
+    fetch?: CustomFetch;
+}
+
+declare interface LayersMeta {
+    experimentsRan?: {
+        id: string;
+        group: 'control' | 'variation';
+    }[];
+    appliedRules?: string[];
+    variantBreakouts?: {
+        id: string;
+        name: string;
+        optionCode: string;
+    }[];
+}
+
+declare interface LayersPagination {
+    page: number;
+    totalPages: number;
+    totalResults: number;
+    resultsPerPage?: number;
+}
+
+declare type LayersProduct = ProductResult;
+
+declare interface LayersResponse extends LayersPagination, LayersFacets {
+    results: (ProductResult | VariantResult_2)[];
+    attributionToken: string;
+    _meta?: LayersMeta;
+}
+
+declare interface LayersTuning {
+    textualWeight?: number;
+    visualWeight?: number;
+    multipleFactor?: number;
+    minimumMatch?: number;
+}
+
+declare interface LayersVariant {
+    id: number;
+    title: string;
+    available: boolean;
+    sku: string;
+    price: string;
+    compare_at_price?: string | null;
+    selected_options: {
+        name: string;
+        value: string;
+        optionValue?: {
+            swatch?: unknown | null;
+            linkedMetafieldValue?: unknown | null;
+        };
+    }[];
+    position: number;
+    featured_media?: FeaturedMedia | null;
+    created_at?: string;
+    updated_at?: string;
+    requires_selling_plan?: boolean;
+    has_selling_plan?: boolean;
+}
+
+export declare function lt(property: string, value: number): FilterExpression;
+
+export declare function lte(property: string, value: number): FilterExpression;
+
+declare interface MatchedVariant extends LayersVariant {
+    metafields?: VariantMetafield[];
+    inventory_policy?: string;
+    inventory_quantity?: number;
+    product_id?: number;
+}
+
+export declare interface Metafield extends MetafieldIdentifier {
+    value: string;
+    type: string;
+}
+
+declare interface MetafieldIdentifier {
+    namespace: string;
+    key: string;
+}
+
+declare interface MetafieldResult {
+    namespace: string;
+    key: string;
+    value: string;
+    type: string;
+}
+
+declare interface MetafieldResult_2 {
+    namespace: string;
+    key: string;
+    value: string;
+    type: string;
+}
+
+declare interface MoneyResult {
+    amount: string;
+    currencyCode: string;
+}
+
+export declare interface NetworkError {
+    readonly _tag: 'NetworkError';
+    readonly code: NetworkErrorCode;
+    readonly message: string;
+    readonly timestamp: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly request?: RequestContext;
+    readonly cause?: unknown;
+}
+
+declare type NetworkErrorCode = 'TIMEOUT' | 'CONNECTION_FAILED' | 'DNS_FAILED' | 'SSL_ERROR' | 'ABORTED' | 'OFFLINE';
+
+export declare function notEq(property: string, value: FilterValue): FilterExpression;
+
+export declare function notExists(property: string): FilterExpression;
+
+export declare function notIn(property: string, values: FilterValue[]): FilterExpression;
+
+declare type OptionSegment = `${string}:${string}`;
+
+declare interface OptionV2 {
+    name: string;
+    code: string;
+    values: {
+        value: string;
+        swatch: {
+            color: string | null;
+            image: {
+                alt: string;
+                url: string;
+            } | null;
+        } | null;
+        linked_metafield_value: unknown | null;
+    }[];
+}
+
+declare interface OptionValueResult {
+    id: string;
+    name: string;
+    swatch: SwatchResult | null;
+}
+
+export declare function or(...expressions: (FilterExpression | FilterGroup)[]): FilterGroup;
+
+declare interface PageMeta {
+    handle: string;
+    title?: string;
+    body?: string;
+    bodySummary?: string;
+    lastFetched: number;
+}
+
+declare interface PredictiveSearchResponse {
+    matchedQueries: {
+        query_text: string;
+        num_searches: number;
+    }[];
+    originalQuery: string;
+    normalizedQuery: string;
+}
+
+declare type PrepareSearchQuery = Pick<SearchQuery, 'query' | 'filters' | 'tuning' | 'signal'>;
+
+declare interface PrepareSearchResult {
+    searchId: string;
+}
+
+export declare interface Price {
+    amount: number;
+    currencyCode: string;
+    formatted: string;
+}
+
+declare interface PriceRangeResult {
+    minVariantPrice: MoneyResult;
+    maxVariantPrice: MoneyResult;
+}
+
+export declare type Product = BaseProduct;
+
+declare interface ProductCategory {
+    id: string;
+    name: string;
+    full_name: string;
+    is_leaf: boolean;
+    is_root: boolean;
+}
+
+declare type ProductExtender<P extends Product = Product> = (input: ProductExtenderInput) => P;
+
+declare interface ProductExtenderInput {
+    base: Product;
+    raw: LayersProduct;
+    shopify: ShopifyProduct | null;
+}
+
+declare type ProductGID = ShopifyGID<'Product'>;
+
+declare interface ProductImage {
+    alt: string;
+    src: string;
+    width: number;
+    height: number;
+    position?: number;
+    variant_ids?: number[];
+}
+
+export declare interface ProductOption {
+    name: string;
+    value: string;
+}
+
+declare interface ProductOptionResult {
+    id: string;
+    name: string;
+    optionValues: OptionValueResult[];
+}
+
+declare interface ProductResult {
+    __typename?: 'Product';
+    id: number;
+    title: string;
+    body_html?: string;
+    vendor?: string;
+    product_type?: string;
+    created_at?: string;
+    handle?: string;
+    updated_at?: string;
+    published_at?: string;
+    tags?: string[];
+    combined_listing_parent_product_id?: number | null;
+    combined_listing_role?: string | null;
+    images?: ProductImage[];
+    metafields?: Record<string, Record<string, unknown>> | unknown[];
+    calculated?: Record<string, unknown> | unknown[];
+    category?: ProductCategory | null;
+    first_or_matched_variant?: MatchedVariant;
+    featured_media?: FeaturedMedia | null;
+    available?: boolean;
+    price_range?: {
+        from: number;
+        to: number;
+        compare_at_price?: number;
+    };
+    options?: Record<string, string[]>;
+    original_options?: Record<string, string[]>;
+    options_v2?: OptionV2[];
+    named_tags?: Record<string, string | number | boolean | string[]> | unknown[];
+    is_gift_card?: boolean;
+    has_variants_that_require_components?: boolean;
+    variants?: LayersVariant[];
+}
+
+export declare interface ProductVariant {
+    id: ID;
+    gid: VariantGID;
+    numericId: number;
+    title: string;
+    availableForSale: boolean;
+    currentlyNotInStock: boolean;
+    quantityAvailable: number;
+    sku: string | null;
+    barcode: string | null;
+    weight: number | null;
+    weightUnit: 'KILOGRAMS' | 'GRAMS' | 'POUNDS' | 'OUNCES' | null;
+    requiresShipping: boolean;
+    price: Price;
+    compareAtPrice: Price | null;
+    image: Image_2 | null;
+    selectedOptions: ProductOption[];
+    metafields: Metafield[];
+}
+
+declare interface QueryResult<P extends Product = Product> {
+    products: P[];
+    totalResults: number;
+    totalPages: number;
+    page: number;
+    facets?: Record<string, Record<string, number>>;
+}
+
+export declare interface QueryState<T> {
+    data: T | null;
+    error: SdkError | null;
+    isFetching: boolean;
+}
+
+export { ReadonlySignal }
+
+declare interface RequestContext {
+    readonly method: HttpMethod;
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+}
+
+declare interface ResponseContext {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers?: Record<string, string>;
+    readonly body?: string;
+}
+
+declare type Result<T, E = Error> = {
+    data: T;
+    error?: never;
+} | {
+    data?: never;
+    error: E;
+};
+
+export declare interface RichProductOption extends ProductOption {
+    swatch?: Swatch;
+}
+
+export declare interface Sdk<P extends Product = Product> {
+    collection: (options: CollectionOptions) => CollectionController<P>;
+    blocks: (options: BlocksOptions) => BlocksController<P>;
+    autocomplete: (options?: AutocompleteOptions) => AutocompleteController;
+    search: () => SearchController<P>;
+    storefront: (query: StorefrontQuery) => ReadonlySignal<QueryState<StorefrontResult<P>>>;
+    uploadImage: (options: UploadImageOptions) => ReadonlySignal<QueryState<UploadImageResult>>;
+    imageSearch: (options: ImageSearchOptions) => ReadonlySignal<QueryState<SearchResult<P>>>;
+    config: SdkConfig<P>;
+    store: Store<P>;
+}
+
+export declare interface SdkConfig<P extends Product = Product> extends LayersClientConfig, Partial<StorefrontClientConfig> {
+    enableStorefront?: boolean;
+    includeMeta?: boolean;
+    currencyCode?: string;
+    formatPrice?: (amount: number, currencyCode: string) => string;
+    swatches?: Swatch[];
+    options?: string[];
+    productMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    variantMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    collectionMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    pageMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    storefrontApiVersion?: string;
+    cacheMaxProducts?: number;
+    cacheMaxEntries?: number;
+    cacheTtl?: number;
+    extendProduct?: ProductExtender<P>;
+    transformFilters?: FilterTransformer;
+    filterMap?: FilterMap;
+    extendCollection?: CollectionExtender<P>;
+    extendSearch?: SearchExtender<P>;
+    extendBlock?: BlocksExtender<P>;
+}
+
+export declare type SdkError = NetworkError | ApiError | ValidationError | ConfigError;
+
+export declare interface SearchController<P extends Product = Product> {
+    state: ReadonlySignal<QueryState<SearchResult<P>>>;
+    prepare: (query: PrepareSearchQuery) => Promise<Result<PrepareSearchResult, SdkError>>;
+    execute: (query: SearchQuery) => Promise<Result<SearchResult<P>, SdkError>>;
+    dispose: () => void;
+}
+
+export declare type SearchExtender<P extends Product = Product> = (result: SearchResult<P>, raw: LayersResponse) => SearchResult<P>;
+
+export declare interface SearchQuery {
+    query: string;
+    searchId?: string;
+    page?: number;
+    limit?: number;
+    filters?: unknown;
+    tuning?: LayersTuning;
+    signal?: AbortSignal;
+}
+
+export declare interface SearchResult<P extends Product = Product> extends LayersPagination {
+    products: P[];
+    facets: Record<string, Record<string, number>>;
+    _meta?: LayersMeta;
+}
+
+declare interface SelectedOptionResult {
+    name: string;
+    value: string;
+}
+
+declare interface SeoResult {
+    title: string | null;
+    description: string | null;
+}
+
+declare interface ShopifyCollection {
+    id: string;
+    handle: string;
+    title: string;
+    description: string;
+    descriptionHtml: string;
+    image: ImageResult | null;
+    seo: SeoResult;
+    updatedAt: string;
+    metafields?: (MetafieldResult | null)[];
+    products?: {
+        filters: FilterResult[];
+    };
+}
+
+declare type ShopifyGID<T extends ShopifyType> = `gid://shopify/${T}/${number}`;
+
+declare interface ShopifyPage {
+    id: string;
+    handle: string;
+    title: string;
+    body: string;
+    bodySummary: string;
+    seo: SeoResult;
+    createdAt: string;
+    updatedAt: string;
+    onlineStoreUrl: string | null;
+    metafields?: (MetafieldResult | null)[];
+}
+
+declare interface ShopifyProduct {
+    id: string;
+    title: string;
+    handle: string;
+    description: string;
+    descriptionHtml: string;
+    vendor: string;
+    productType: string;
+    tags: string[];
+    availableForSale: boolean;
+    isGiftCard: boolean;
+    totalInventory: number;
+    onlineStoreUrl: string | null;
+    featuredImage: ImageResult | null;
+    images: {
+        nodes: ImageResult[];
+    };
+    priceRange: PriceRangeResult;
+    compareAtPriceRange: PriceRangeResult;
+    options: ProductOptionResult[];
+    variants: {
+        nodes: VariantResult[];
+    };
+    selectedOrFirstAvailableVariant: VariantResult | null;
+    metafields?: (MetafieldResult | null)[];
+}
+
+declare type ShopifyType = 'Product' | 'ProductVariant' | 'Collection';
+
+export { Signal }
+
+export { signal }
+
+declare interface Sort {
+    label: string;
+    code: string;
+}
+
+declare interface Store<P extends Product = Product> {
+    products: {
+        get(gid: ProductGID): P | undefined;
+        getMany(gids: ProductGID[]): {
+            cached: P[];
+            missing: ProductGID[];
+        };
+        set(products: P[]): void;
+        has(gid: ProductGID): boolean;
+    };
+    queries: {
+        get(key: string): ReadonlySignal<Entry<QueryResult<P>> | null>;
+        set(key: string, result: QueryResult<P>): void;
+        isExpired(key: string): boolean;
+        invalidate(pattern: string): void;
+    };
+    collections: {
+        get(handle: string): CollectionMeta | undefined;
+        set(handle: string, meta: Omit<CollectionMeta, 'handle'>): void;
+        delete(handle: string): void;
+    };
+    pages: {
+        get(handle: string): PageMeta | undefined;
+        set(handle: string, meta: Omit<PageMeta, 'handle'>): void;
+        delete(handle: string): void;
+    };
+    persist(): void;
+    restore(): void;
+    clear(): void;
+    readonly stats: {
+        products: number;
+        queries: number;
+        collections: number;
+        pages: number;
+    };
+}
+
+declare interface StorefrontClientConfig {
+    shop: string;
+    storefrontPublicToken: string;
+    storefrontApiVersion?: string;
+    fetch?: CustomFetch;
+}
+
+export declare interface StorefrontQuery {
+    ids: string[];
+    meta?: {
+        collection?: string;
+        page?: string;
+        includeFilters?: boolean;
+    };
+    productMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    variantMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    collectionMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    pageMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    signal?: AbortSignal;
+}
+
+export declare interface StorefrontResult<P extends Product = Product> {
+    products: P[];
+    collection?: ShopifyCollection;
+    page?: ShopifyPage;
+}
+
+export declare interface Swatch {
+    name: string | null;
+    value: string;
+    color: string | null;
+    imageUrl: string | null;
+}
+
+declare interface SwatchResult {
+    color: string | null;
+    image: {
+        previewImage: {
+            url: string;
+        };
+    } | null;
+}
+
+export declare interface UploadImageOptions {
+    image: File | Blob;
+    signal?: AbortSignal;
+}
+
+export declare interface UploadImageResult {
+    imageId: string;
+}
+
+export declare interface ValidationError {
+    readonly _tag: 'ValidationError';
+    readonly code: 'VALIDATION_FAILED';
+    readonly message: string;
+    readonly timestamp: string;
+    readonly operation: string;
+    readonly fields: ValidationFieldError[];
+    readonly input?: unknown;
+}
+
+declare type ValidationErrorCode = 'REQUIRED_FIELD' | 'INVALID_TYPE' | 'INVALID_FORMAT' | 'OUT_OF_RANGE' | 'INVALID_LENGTH' | 'INVALID_PATTERN' | 'INVALID_ENUM';
+
+declare interface ValidationFieldError {
+    readonly path: string[];
+    readonly field: string;
+    readonly code: ValidationErrorCode;
+    readonly message: string;
+    readonly value?: unknown;
+    readonly expected?: string;
+    readonly constraints?: {
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        allowedValues?: string[];
+    };
+}
+
+declare type VariantGID = ShopifyGID<'ProductVariant'>;
+
+declare interface VariantMetafield {
+    key: string;
+    value: string;
+    namespace: string;
+    created_at: string;
+    updated_at: string;
+    value_type: string;
+    compare_digest: string;
+}
+
+declare interface VariantResult {
+    id: string;
+    title: string;
+    availableForSale: boolean;
+    currentlyNotInStock: boolean;
+    quantityAvailable: number;
+    sku: string | null;
+    barcode: string | null;
+    weight: number | null;
+    weightUnit: 'KILOGRAMS' | 'GRAMS' | 'POUNDS' | 'OUNCES' | null;
+    requiresShipping: boolean;
+    price: MoneyResult;
+    compareAtPrice: MoneyResult | null;
+    selectedOptions: SelectedOptionResult[];
+    image: ImageResult | null;
+    metafields?: (MetafieldResult | null)[];
+}
+
+declare interface VariantResult_2 extends Omit<ProductResult, '__typename'> {
+    __typename: 'Variant';
+    product_id: number;
+    variant_id: number;
+}
+
+export { }