@commerce-blocks/sdk 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/index.d.ts

@@ -7,40 +7,32 @@ import { signal } from '@preact/signals-core';
 
 export declare function and(...expressions: (FilterExpression | FilterGroup)[]): FilterGroup;
 
+declare interface ApiClientConfig extends ApiFetchConfig {
+    sorts: Sort[];
+    facets: Facet[];
+    attributes?: string[];
+}
+
 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' | 'NOT_READY' | 'RATE_LIMITED' | 'SERVICE_UNAVAILABLE' | 'GRAPHQL_ERROR' | 'PARSE_ERROR' | 'UNKNOWN';
+declare type ApiErrorCode = 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'NOT_READY' | 'RATE_LIMITED' | 'SERVICE_UNAVAILABLE' | 'PARSE_ERROR' | 'UNKNOWN';
 
-declare type ApiSource = 'layers' | 'storefront';
-
-export declare interface AutocompleteController {
-    readonly state: ReadonlySignal<QueryState<PredictiveSearchResponse>>;
-    execute(query: string): void;
-    subscribe(callback: (state: QueryState<PredictiveSearchResponse>) => void): Unsubscribe;
-    dispose(): void;
+declare interface ApiFetchConfig {
+    token: string;
+    baseUrl?: string;
+    fetch?: CustomFetch;
 }
 
-export declare interface AutocompleteOptions {
-    debounceMs?: number;
-    signal?: AbortSignal;
-}
+declare type ApiSource = 'layers';
 
 export { batch }
 
@@ -58,16 +50,7 @@ declare interface BlocksContext {
     custom?: Record<string, unknown>;
 }
 
-export declare interface BlocksController<P extends Product = Product> {
-    readonly state: ReadonlySignal<QueryState<BlocksResult<P>>>;
-    execute(query?: BlocksQuery): Promise<Result<BlocksResult<P>, SdkError>>;
-    subscribe(callback: (state: QueryState<BlocksResult<P>>) => void): Unsubscribe;
-    dispose(): void;
-}
-
-export declare type BlocksExtender<P extends Product = Product> = (result: BlocksResult<P>, raw: LayersResponse & {
-    block?: BlocksInfo;
-}) => BlocksResult<P>;
+export declare type BlocksController = Controller<BlocksResult, BlocksQuery>;
 
 declare interface BlocksInfo {
     id: string;
@@ -80,73 +63,98 @@ declare interface BlocksInfo {
 
 export declare interface BlocksOptions {
     blockId: string;
-    anchorId?: string;
+    anchor?: string;
 }
 
 export declare interface BlocksQuery extends QueryParams {
-    discountEntitlements?: DiscountEntitlement[];
+    discounts?: DiscountEntitlement[];
     context?: BlocksContext;
 }
 
-export declare interface BlocksResult<P extends Product = Product> extends QueryResult<P> {
+export declare interface BlocksResult extends QueryResult {
     block?: BlocksInfo;
 }
 
-export declare type BodyTransformer = (body: Record<string, unknown>) => Record<string, unknown>;
+declare interface Cache_2 {
+    get(key: string): CacheEntry<QueryResult> | null;
+    set(key: string, result: QueryResult): void;
+    isExpired(key: string): boolean;
+    invalidate(pattern: string): void;
+    persist(): void;
+    restore(): void;
+    clear(): void;
+    readonly stats: {
+        entries: number;
+    };
+}
+
+declare type CacheData = Record<string, QueryResult>;
 
 declare interface CacheEntry<T> {
     data: T;
     timestamp: number;
 }
 
-export declare interface CollectionController<P extends Product = Product> {
-    readonly state: ReadonlySignal<QueryState<CollectionResult<P>>>;
-    execute(query?: CollectionQuery): Promise<Result<CollectionResult<P>, SdkError>>;
-    subscribe(callback: (state: QueryState<CollectionResult<P>>) => void): Unsubscribe;
-    dispose(): void;
+export declare interface CacheOptions {
+    ttl?: number;
+    maxEntries?: number;
+    storageKey?: string;
+    /** Custom storage adapter. Defaults to localStorage in browser. */
+    storageAdapter?: StorageAdapter;
 }
 
-export declare type CollectionExtender<P extends Product = Product> = (result: CollectionResult<P>, raw: LayersResponse) => CollectionResult<P>;
+export declare interface Client {
+    collection: (options: CollectionOptions) => CollectionController;
+    blocks: (options: BlocksOptions) => BlocksController;
+    suggest: (options?: SuggestOptions) => SuggestController;
+    search: (options?: SearchQuery) => SearchController;
+    uploadImage: (options: UploadImageOptions) => UploadImageController;
+    searchByImage: (options: SearchByImageQuery) => SearchByImageController;
+    config: ClientConfig;
+    cache: Cache_2;
+}
 
-declare interface CollectionMeta {
-    handle: string;
-    title?: string;
-    description?: string;
-    descriptionHtml?: string;
-    image?: {
-        url: string;
-        alt?: string;
-        width?: number;
-        height?: number;
-    };
-    metafields?: (Metafield | null)[];
-    totalProducts: number;
-    totalPages: number;
-    lastPageFetched: number;
-    facets?: Record<string, Record<string, number>>;
-    lastFetched: number;
+export declare interface ClientConfig extends ApiClientConfig {
+    includeMeta?: boolean;
+    currency?: string;
+    formatPrice?: (amount: number, currencyCode: string) => string;
+    swatches?: Swatch[];
+    options?: string[];
+    productMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    variantMetafields?: {
+        namespace: string;
+        key: string;
+    }[];
+    cacheLimit?: number;
+    cacheLifetime?: number;
+    /** Custom storage adapter for cache persistence. Defaults to localStorage in browser. */
+    storage?: StorageAdapter;
+    transforms?: Transforms;
+    filterAliases?: FilterAliases;
+    /** Initial data to hydrate into the cache */
+    initialData?: CacheData;
+    /** Restore cache from storage on init (default: true) */
+    restoreCache?: boolean;
 }
 
+export declare type ClientError = ServiceError | ConfigError;
+
+export declare type CollectionController = Controller<CollectionResult, CollectionQuery>;
+
 export declare interface CollectionOptions {
     handle: string;
     defaultSort?: string;
 }
 
 export declare interface CollectionQuery extends QueryParams {
-    sortOrderCode?: string;
+    sort?: string;
     includeMeta?: boolean;
-    collectionMetafields?: {
-        namespace: string;
-        key: string;
-    }[];
-    includeFilters?: boolean;
 }
 
-export declare interface CollectionResult<P extends Product = Product> extends QueryResult<P> {
-    collection?: StorefrontCollection;
-}
-
-declare type Collections = Record<string, Omit<CollectionMeta, 'handle'>>;
+export declare type CollectionResult = QueryResult;
 
 declare type CommerceBlocksID = `${CommerceBlocksType}-${OptionSegment}` | `${CommerceBlocksType}-${OptionSegment}-${OptionSegment}` | `${CommerceBlocksType}-${OptionSegment}-${OptionSegment}-${OptionSegment}`;
 
@@ -158,7 +166,6 @@ 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;
@@ -168,22 +175,18 @@ declare type ConfigErrorCode = 'MISSING_CONFIG' | 'INVALID_CONFIG';
 
 export declare interface Controller<TData, TQuery = void> {
     readonly state: ReadonlySignal<QueryState<TData>>;
-    execute(query: TQuery): Promise<Result<TData, SdkError>>;
+    execute(query?: TQuery): Promise<Result<TData, ClientError>>;
     subscribe(callback: (state: QueryState<TData>) => void): Unsubscribe;
     dispose(): void;
 }
 
-export declare function createProductCard({ product, selectedOptions: initialSelectedOptions, breakoutOptions: initialBreakoutOptions, }: CreateProductCardParams): ProductCardController;
+export declare function createClient(config: ClientConfig): Result<Client, ConfigError>;
 
-export declare interface CreateProductCardParams {
-    product: Product | ExtendedProduct;
-    selectedOptions?: ProductOption[];
-    breakoutOptions?: ProductOption[];
-}
+export declare type CreateClientResult = Result<Client, ConfigError>;
 
-export declare function createSdk<P extends Product = Product>(config: SdkConfig<P>): Result<Sdk<P>, ConfigError>;
+export declare function createProductCard({ product, selectedOptions: initialSelectedOptions, breakoutOptions: initialBreakoutOptions, }: ProductCardOptions): ProductCardController;
 
-declare type CustomFetch = (url: string, init?: RequestInit) => Promise<Response>;
+export declare type CustomFetch = (url: string, init?: RequestInit) => Promise<Response>;
 
 declare interface DiscountEntitlement {
     entitled: {
@@ -204,10 +207,6 @@ export declare function eq(property: string, value: FilterValue): FilterExpressi
 
 export declare function exists(property: string): FilterExpression;
 
-declare interface ExtendedProduct extends Product {
-    _base: Product;
-}
-
 declare interface Facet {
     name: string;
     code: string;
@@ -222,13 +221,16 @@ declare interface FeaturedMedia {
 }
 
 declare interface FeaturedMedia_2 {
-    mediaContentType?: string;
-    alt: string;
+    id: number;
     src: string;
+    alt: string | null;
+    media_type: string;
     width: number;
     height: number;
 }
 
+export declare function fileStorage(filePath: string, fs: FileSystem_2): StorageAdapter;
+
 declare interface FileSystem_2 {
     readFileSync(path: string, encoding: 'utf-8'): string;
     writeFileSync(path: string, data: string, encoding: 'utf-8'): void;
@@ -238,6 +240,13 @@ export { FileSystem_2 as FileSystem }
 
 export declare function filter(expression: FilterExpression | FilterGroup): FilterGroup;
 
+export declare type FilterAlias = string | {
+    property: string;
+    values?: Record<string, string>;
+};
+
+export declare type FilterAliases = Record<string, FilterAlias>;
+
 declare enum FilterConditional {
     And = "AND",
     Or = "OR"
@@ -254,13 +263,6 @@ export declare interface FilterGroup {
     expressions: (FilterExpression | 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",
@@ -274,58 +276,14 @@ declare enum FilterOperator {
     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 interface FireAndForgetController<TData, TQuery = void> {
-    readonly state: ReadonlySignal<QueryState<TData>>;
-    execute(query: TQuery): void;
-    subscribe(callback: (state: QueryState<TData>) => void): Unsubscribe;
-    dispose(): void;
-}
-
-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 getClient(): Result<Client, ConfigError>;
 
 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 interface Image_2 {
     url: string;
     alt: string;
@@ -336,36 +294,16 @@ declare interface Image_2 {
 }
 export { Image_2 as Image }
 
-declare interface ImageResult {
-    url: string;
-    altText: string | null;
-    width: number;
-    height: number;
-}
-
-export declare interface ImageSearchQuery extends QueryParams {
-    imageId: string;
-    tuning?: LayersTuning;
-}
-
 export declare function inValues(property: string, values: FilterValue[]): FilterExpression;
 
 /** Map of location ID to available quantity */
 declare type InventoryLevels = Record<string, number>;
 
-export declare function isInitialized(): boolean;
-
-export declare function isRetryable(error: SdkError): boolean;
+export declare function isClientError(error: unknown): error is ClientError;
 
-export declare function isSdkError(error: unknown): error is SdkError;
-
-export declare function jsonFileAdapter(filePath: string, fs: FileSystem_2): StorageAdapter;
+export declare function isInitialized(): boolean;
 
-declare interface LayersClientConfig extends LayersFetchConfig {
-    sorts: Sort[];
-    facets: Facet[];
-    attributes?: string[];
-}
+export declare function isRetryable(error: ClientError): boolean;
 
 declare interface LayersFacets {
     facets?: Record<string, Record<string, number>>;
@@ -375,12 +313,6 @@ declare interface LayersFacets {
     }>;
 }
 
-declare interface LayersFetchConfig {
-    layersPublicToken: string;
-    layersBaseUrl?: string;
-    fetch?: CustomFetch;
-}
-
 declare interface LayersMeta {
     experimentsRan?: {
         id: string;
@@ -418,36 +350,20 @@ declare interface LayersResponse extends LayersPagination, LayersFacets {
 
 declare type LayersResult = ProductResult | VariantResult;
 
-declare interface LayersTuning {
-    textualWeight?: number;
-    visualWeight?: number;
-    multipleFactor?: number;
-    minimumMatch?: number;
-    missingEmbeddingScore?: number;
-    highSignalWeight?: 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;
-        };
-    }[];
+    sku: string | null;
     position: number;
-    featured_media?: FeaturedMedia_2 | null;
-    created_at?: string;
-    updated_at?: string;
-    requires_selling_plan?: boolean;
-    has_selling_plan?: boolean;
+    compare_at_price: string | null;
+    selected_options: SelectedOption[];
+    created_at: string;
+    updated_at: string;
+    available: boolean;
+    featured_media: FeaturedMedia_2 | null;
+    requires_selling_plan: boolean | null;
+    has_selling_plan: boolean | null;
     inventory_levels?: InventoryLevels;
     in_stock_location_ids?: number[];
 }
@@ -476,31 +392,12 @@ declare interface MetafieldIdentifier {
     key: string;
 }
 
-declare interface MetafieldResult {
-    namespace: string;
-    key: string;
-    value: string;
-    type: string;
-}
-
-declare interface MoneyResult {
-    amount: string;
-    currencyCode: string;
-}
-
-declare interface NamedTag {
-    name: string;
-    value: string | number | boolean | 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;
 }
 
@@ -512,10 +409,15 @@ export declare function notExists(property: string): FilterExpression;
 
 export declare function notIn(property: string, values: FilterValue[]): FilterExpression;
 
-declare type OptionAvailabilityStatus = 'available' | 'backorderable' | 'sold-out' | 'unavailable';
+export declare interface OptionGroup {
+    name: string;
+    values: OptionValue[];
+}
 
 declare type OptionSegment = `${string}:${string}`;
 
+export declare type OptionStatus = 'available' | 'backorderable' | 'sold-out' | 'unavailable';
+
 declare interface OptionV2 {
     name: string;
     code: string;
@@ -524,127 +426,109 @@ declare interface OptionV2 {
         swatch: {
             color: string | null;
             image: {
-                alt: string;
-                url: string;
+                alt: string | null;
+                url: string | null;
             } | null;
         } | null;
-        linked_metafield_value: unknown | null;
+        linked_metafield_value: unknown;
     }[];
 }
 
-declare interface OptionValueResult {
-    id: string;
-    name: string;
-    swatch: SwatchResult | null;
+export declare interface OptionValue {
+    value: string;
+    status: OptionStatus;
+    selected: boolean;
+    swatch: Swatch | null;
 }
 
 export declare function or(...expressions: (FilterExpression | FilterGroup)[]): FilterGroup;
 
-declare interface PageMeta {
-    handle: string;
-    title?: string;
-    body?: string;
-    bodySummary?: string;
-    lastFetched: number;
-}
-
-export declare type ParamDefinition = (key: string) => unknown | undefined | null;
-
-export declare type ParamDefinitions = Record<string, ParamDefinition>;
-
-declare interface PredictiveSearchResponse {
-    matchedQueries: {
-        query_text: string;
-        num_searches: number;
-    }[];
-    originalQuery: string;
-    normalizedQuery: string;
-}
-
-export declare interface PreparableController<TData, TQuery, TPrepareResult> extends Controller<TData, TQuery> {
-    prepare(query: TQuery): Promise<Result<TPrepareResult, SdkError>>;
-}
-
-export declare interface PrepareSearchResult {
-    searchId: string;
-}
-
 export declare interface Price {
     amount: number;
     currencyCode: string;
     formatted: string;
 }
 
+export declare interface PriceData {
+    price: Price | null;
+    compareAtPrice: Price | null;
+    isOnSale: boolean;
+}
+
 export declare interface PriceRange {
     min: Price;
     max: Price;
 }
 
-declare interface PriceRangeResult {
-    minVariantPrice: MoneyResult;
-    maxVariantPrice: MoneyResult;
+export declare interface PriceRangeData {
+    priceRange: PriceRange;
+    compareAtPriceRange: PriceRange | null;
 }
 
-export declare interface Product {
+export declare type Product<T extends Record<string, unknown> = Record<string, unknown>> = ProductBase & T;
+
+export declare interface ProductBase {
     id: CommerceBlocksID;
     gid: ProductGID;
     numericId: number;
     title: string;
     handle: string;
-    type: string;
     vendor: string;
-    description: string;
+    type: string;
     availableForSale: boolean;
+    tags: string[];
     images: Image_2[];
+    featuredMedia: FeaturedMedia | null;
     priceRange: PriceRange;
-    compareAtPriceRange?: PriceRange;
+    compareAtPriceRange: PriceRange | undefined;
     options: RichProductOption[];
-    tags: string[];
-    variants: ProductVariant[];
     selectedOptions: ProductOption[];
-    metafields: Record<string, Record<string, unknown>> | unknown[];
-    calculated?: Record<string, unknown>;
-    isGiftCard: boolean;
+    variants: ProductVariant[];
+    selectedVariant: ProductVariant | null;
+    metafields: Record<string, Record<string, unknown>>;
+    calculated: Record<string, unknown>;
     category: ProductCategory | null;
-    createdAt: string | null;
-    publishedAt: string | null;
-    updatedAt: string | null;
-    featuredMedia: FeaturedMedia | null;
-    namedTags?: NamedTag[];
     combinedListingParentProductId: number | null;
     combinedListingRole: string | null;
-    hasVariantsThatRequireComponents: boolean;
-    originalOptions: Record<string, string[]>;
-    selectedVariant: ProductVariant | null;
-    breakoutOptions?: ProductOption[];
-    breakoutVariantId?: number;
+    breakoutOptions: ProductOption[];
+    breakoutVariantId: number | null;
 }
 
 export declare interface ProductCardController {
     product: Product;
     variants: ReadonlySignal<ProductVariant[]>;
     selectedVariant: ReadonlySignal<ProductVariant | null>;
-    selectedOptions: ReadonlySignal<ProductOption[]>;
-    options: ReadonlySignal<RichProductOption[]>;
-    optionNames: ReadonlySignal<string[]>;
-    swatchOptionName: ReadonlySignal<string | null>;
+    options: ReadonlySignal<OptionGroup[]>;
     images: ReadonlySignal<Image_2[]>;
-    allImages: ReadonlySignal<Image_2[]>;
-    carouselIndex: ReadonlySignal<number>;
+    price: ReadonlySignal<PriceData>;
+    priceRange: ReadonlySignal<PriceRangeData>;
+    carouselPosition: ReadonlySignal<number>;
     isSelectionComplete: ReadonlySignal<boolean>;
-    selectOption(name: string, value: string): void;
+    selectOption(option: ProductOption): void;
     setSelectedOptions(options: ProductOption[]): void;
-    setBreakoutOptions(options: ProductOption[]): void;
-    getOptionValues(name: string): string[];
-    getSwatches(name: string): Swatch[];
-    getVariantByOptions(options: ProductOption[]): ProductVariant | null;
-    getCarouselIndexForVariant(variant: ProductVariant): number;
-    isOptionAvailable(name: string, value: string): boolean;
-    isVariantAvailable(variant: ProductVariant): boolean;
-    getOptionAvailabilityStatus(name: string, value: string): OptionAvailabilityStatus;
+    setSelectedVariant(variantId: number): void;
+    setCarouselPosition(position: number): void;
+    subscribe(callback: (state: ProductCardState) => void): Unsubscribe_2;
     dispose(): void;
 }
 
+export declare interface ProductCardOptions {
+    product: Product;
+    selectedOptions?: ProductOption[];
+    breakoutOptions?: ProductOption[];
+}
+
+export declare interface ProductCardState {
+    variants: ProductVariant[];
+    selectedVariant: ProductVariant | null;
+    options: OptionGroup[];
+    images: Image_2[];
+    price: PriceData;
+    priceRange: PriceRangeData;
+    carouselPosition: number;
+    isSelectionComplete: boolean;
+}
+
 declare interface ProductCategory {
     id: string;
     name: string;
@@ -661,19 +545,19 @@ declare interface ProductCategory_2 {
     is_root: boolean;
 }
 
-declare type ProductExtender<P extends Product = Product> = (input: ProductExtenderInput) => P;
+declare type ProductExtender = (input: ProductExtenderInput) => Record<string, unknown>;
 
 declare interface ProductExtenderInput {
     base: Product;
     raw: LayersResult;
-    storefront: StorefrontProduct | null;
 }
 
 declare type ProductGID = ShopifyGID<'Product'>;
 
 declare interface ProductImage {
-    alt: string;
+    id: number;
     src: string;
+    alt: string | null;
     width: number;
     height: number;
     position?: number;
@@ -685,45 +569,40 @@ export declare interface ProductOption {
     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_2 | null;
-    first_or_matched_variant?: MatchedVariant;
-    featured_media?: FeaturedMedia_2 | null;
-    available?: boolean;
-    price_range?: {
+    handle: string;
+    available: boolean;
+    vendor: string | null;
+    product_type: string | null;
+    combined_listing_role: string | null;
+    combined_listing_parent_product_id: number | null;
+    featured_media: FeaturedMedia_2 | null;
+    category: ProductCategory_2 | null;
+    tags: string[];
+    images: ProductImage[];
+    collection_titles: string[];
+    metafields: Record<string, Record<string, unknown>>;
+    calculated: Record<string, unknown>;
+    price_range: {
         from: number;
         to: number;
-        compare_at_price?: number;
+        compare_at_price: number;
     };
-    options?: Record<string, string[]>;
+    options: Record<string, string[]>;
+    options_v2: OptionV2[];
+    body_html?: string | null;
+    is_gift_card?: boolean | null;
+    has_variants_that_require_components?: boolean | null;
+    named_tags?: 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[];
+    created_at?: string;
+    updated_at?: string;
+    published_at?: string;
+    first_or_matched_variant?: MatchedVariant;
+    variants: LayersVariant[];
 }
 
 export declare interface ProductVariant {
@@ -731,15 +610,13 @@ export declare interface ProductVariant {
     gid: VariantGID;
     numericId: number;
     title: string;
-    availableForSale: boolean;
-    currentlyNotInStock: boolean;
     sku: string | null;
     position: number;
+    availableForSale: boolean;
     price: Price;
     compareAtPrice: Price | null;
     image: Image_2 | null;
     selectedOptions: ProductOption[];
-    metafields: Metafield[];
     inventoryLevels: InventoryLevels;
     inventoryPolicy: 'DENY' | 'CONTINUE' | null;
     inStockLocationIds: number[];
@@ -747,45 +624,30 @@ export declare interface ProductVariant {
     hasSellingPlan: boolean;
 }
 
-declare type Queries<P extends Product = Product> = Record<string, QueryResult<P>>;
-
 export declare interface QueryParams {
     page?: number;
     limit?: number;
     filters?: unknown;
     signal?: AbortSignal;
-    dynamicLinking?: Record<string, string | number | (string | number)[]>;
-    params?: Record<string, unknown>;
-    paramDefinitions?: ParamDefinitions;
-    transformBody?: BodyTransformer;
+    linking?: Record<string, string | number | (string | number)[]>;
+    transformRequest?: RequestTransformer;
 }
 
-declare interface QueryResult<P extends Product = Product> extends Omit<LayersResponse, 'results' | 'facets'> {
-    products: P[];
+declare interface QueryResult extends Omit<LayersResponse, 'results' | 'facets'> {
+    products: Product[];
     facets: Record<string, Record<string, number>>;
     priceRange?: PriceRange;
 }
 
 export declare interface QueryState<T> {
     data: T | null;
-    error: SdkError | null;
+    error: ClientError | 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;
-}
+export declare type RequestTransformer = (body: Record<string, unknown>) => Record<string, unknown>;
 
 declare type Result<T, E = Error> = {
     data: T;
@@ -799,92 +661,62 @@ 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: (options?: SearchQuery) => SearchController<P>;
-    storefront: (query: StorefrontQuery) => ReadonlySignal<QueryState<StorefrontResult<P>>>;
-    uploadImage: (options: UploadImageOptions) => ReadonlySignal<QueryState<UploadImageResult>>;
-    imageSearch: (options: ImageSearchQuery) => ReadonlySignal<QueryState<SearchResult<P>>>;
-    config: SdkConfig<P>;
-    store: Store<P>;
+export declare interface SearchByImageController {
+    readonly state: ReadonlySignal<QueryState<SearchResult>>;
+    subscribe(callback: (state: QueryState<SearchResult>) => void): Unsubscribe;
+    dispose(): void;
 }
 
-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;
-    /** Custom storage adapter for cache persistence. Defaults to localStorage in browser. */
-    storageAdapter?: StorageAdapter;
-    extendProduct?: ProductExtender<P>;
-    transformFilters?: FilterTransformer;
-    filterMap?: FilterMap;
-    extendCollection?: CollectionExtender<P>;
-    extendSearch?: SearchExtender<P>;
-    extendBlock?: BlocksExtender<P>;
-    /** Initial data to hydrate into the store */
-    initialData?: {
-        products?: P[];
-        queries?: Queries<P>;
-        collections?: Collections;
-    };
-    /** Restore cache from storage on init (default: true) */
-    restoreFromStorage?: boolean;
+export declare interface SearchByImageQuery extends QueryParams {
+    imageId: string;
+    tuning?: SearchTuning;
 }
 
-export declare type SdkError = ServiceError | ConfigError;
-
-export declare interface SearchController<P extends Product = Product> {
-    readonly state: ReadonlySignal<QueryState<SearchResult<P>>>;
-    prepare(query?: SearchQuery): Promise<Result<PrepareSearchResult, SdkError>>;
-    execute(query?: SearchQuery): Promise<Result<SearchResult<P>, SdkError>>;
-    subscribe(callback: (state: QueryState<SearchResult<P>>) => void): Unsubscribe;
+export declare interface SearchController {
+    readonly state: ReadonlySignal<QueryState<SearchResult>>;
+    prepare(query?: SearchQuery): Promise<Result<SearchPrepareResult, ClientError>>;
+    execute(query?: SearchQuery): Promise<Result<SearchResult, ClientError>>;
+    subscribe(callback: (state: QueryState<SearchResult>) => void): Unsubscribe;
     dispose(): void;
 }
 
-export declare type SearchExtender<P extends Product = Product> = (result: SearchResult<P>, raw: LayersResponse) => SearchResult<P>;
+export declare interface SearchPrepareResult {
+    searchId: string;
+}
 
 export declare interface SearchQuery extends QueryParams {
     query?: string;
     searchId?: string;
-    tuning?: LayersTuning;
-    transient?: boolean;
+    tuning?: SearchTuning;
+    temporary?: boolean;
 }
 
-export declare type SearchResult<P extends Product = Product> = QueryResult<P>;
+export declare type SearchResult = QueryResult;
 
-declare interface SelectedOptionResult {
-    name: string;
-    value: string;
+declare interface SearchTuning {
+    textualWeight?: number;
+    visualWeight?: number;
+    multipleFactor?: number;
+    minimumMatch?: number;
+    missingEmbeddingScore?: number;
+    highSignalWeight?: number;
 }
 
-declare interface SeoResult {
-    title: string | null;
-    description: string | null;
+declare interface SelectedOption {
+    name: string;
+    value: string;
+    optionValue?: {
+        swatch?: {
+            color: string | null;
+            image: {
+                image: {
+                    url: string;
+                    altText: string | null;
+                };
+            } | null;
+        };
+        linkedMetafieldValue?: unknown;
+    };
 }
 
 declare type ServiceError = NetworkError | ApiError | ValidationError;
@@ -912,149 +744,31 @@ export declare interface StorageAdapter {
     remove(): void;
 }
 
-declare interface Store<P extends Product = Product> {
-    products: {
-        get(gid: ProductGID): P | undefined;
-        getMany(gids: ProductGID[]): {
-            cached: P[];
-            missing: ProductGID[];
-        };
-        set(products: P | P[]): void;
-        has(gid: ProductGID): boolean;
-    };
-    queries: {
-        get(key: string): ReadonlySignal<CacheEntry<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;
-}
-
-declare interface StorefrontCollection {
-    id: string;
-    handle: string;
-    title: string;
-    description: string;
-    descriptionHtml: string;
-    image: ImageResult | null;
-    seo: SeoResult;
-    updatedAt: string;
-    metafields?: (MetafieldResult | null)[];
-    products?: {
-        filters: FilterResult[];
-    };
-}
+/**
+ * Subscribe to state changes. Callback fires immediately, then on every change.
+ */
+export declare function subscribe<T>(state: ReadonlySignal<T>, callback: (value: T) => void): () => void;
 
-declare interface StorefrontPage {
-    id: string;
-    handle: string;
-    title: string;
-    body: string;
-    bodySummary: string;
-    seo: SeoResult;
-    createdAt: string;
-    updatedAt: string;
-    onlineStoreUrl: string | null;
-    metafields?: (MetafieldResult | null)[];
+export declare interface SuggestController {
+    readonly state: ReadonlySignal<QueryState<Suggestions>>;
+    execute(query: string): void;
+    subscribe(callback: (state: QueryState<Suggestions>) => void): Unsubscribe;
+    dispose(): void;
 }
 
-declare interface StorefrontProduct {
-    id: string;
-    title: string;
-    handle: string;
-    description: string;
-    descriptionHtml: string;
-    vendor: string;
-    productType: string;
-    tags: string[];
-    availableForSale: boolean;
-    isGiftCard: boolean;
-    featuredImage: ImageResult | null;
-    images: {
-        nodes: ImageResult[];
-    };
-    priceRange: PriceRangeResult;
-    compareAtPriceRange: PriceRangeResult;
-    options: ProductOptionResult[];
-    variants: {
-        nodes: VariantResult_2[];
-    };
-    selectedOrFirstAvailableVariant: VariantResult_2 | null;
-    metafields?: (MetafieldResult | null)[];
+declare interface Suggestions {
+    matchedQueries: string[];
+    originalQuery: string;
+    normalizedQuery: string;
 }
 
-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;
-    }[];
+export declare interface SuggestOptions {
+    debounce?: number;
+    excludeInputQuery?: boolean;
+    excludeQueries?: string[];
     signal?: AbortSignal;
 }
 
-export declare interface StorefrontResult<P extends Product = Product> {
-    products: P[];
-    collection?: StorefrontCollection;
-    page?: StorefrontPage;
-}
-
-export declare interface StoreOptions {
-    ttl?: number;
-    maxProducts?: number;
-    maxQueries?: number;
-    storageKey?: string;
-    /** Custom storage adapter. Defaults to localStorage in browser. */
-    storageAdapter?: StorageAdapter;
-}
-
-/**
- * Subscribe to state changes. Callback fires immediately, then on every change.
- */
-export declare function subscribe<T>(state: ReadonlySignal<QueryState<T>>, callback: (state: QueryState<T>) => void): Unsubscribe;
-
 export declare interface Swatch {
     name: string | null;
     value: string;
@@ -1062,17 +776,26 @@ export declare interface Swatch {
     imageUrl: string | null;
 }
 
-declare interface SwatchResult {
-    color: string | null;
-    image: {
-        previewImage: {
-            url: string;
-        };
-    } | null;
+export declare interface Transforms {
+    product?: ProductExtender;
+    collection?: (result: CollectionResult, raw: LayersResponse) => CollectionResult;
+    search?: (result: SearchResult, raw: LayersResponse) => SearchResult;
+    block?: (result: BlocksResult, raw: LayersResponse & {
+        block?: BlocksInfo;
+    }) => BlocksResult;
+    filters?: (filters: unknown) => FilterGroup | undefined;
 }
 
 export declare type Unsubscribe = () => void;
 
+declare type Unsubscribe_2 = () => void;
+
+export declare interface UploadImageController {
+    readonly state: ReadonlySignal<QueryState<UploadImageResult>>;
+    subscribe(callback: (state: QueryState<UploadImageResult>) => void): Unsubscribe;
+    dispose(): void;
+}
+
 export declare interface UploadImageOptions {
     image: File | Blob;
     signal?: AbortSignal;
@@ -1086,28 +809,21 @@ 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 type ValidationErrorCode = 'REQUIRED_FIELD' | 'OUT_OF_RANGE';
 
 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[];
     };
 }
 
@@ -1129,17 +845,6 @@ declare interface VariantResult extends Omit<ProductResult, '__typename'> {
     variant_id: number;
 }
 
-declare interface VariantResult_2 {
-    id: string;
-    title: string;
-    availableForSale: boolean;
-    currentlyNotInStock: boolean;
-    sku: string | null;
-    price: MoneyResult;
-    compareAtPrice: MoneyResult | null;
-    selectedOptions: SelectedOptionResult[];
-    image: ImageResult | null;
-    metafields?: (MetafieldResult | null)[];
-}
+export declare function xhrFetch(url: string, init?: RequestInit): Promise<Response>;
 
 export { }