headless-js-api/dist/api/index.d.cts

Headless JS client for Ecwid public API

import { A as ApiConfig } from '../api-config-BpaxQA1V.cjs';
import { Blob } from 'buffer';

/**
 * Paginated response
 * @template T - The type of the items in the response.
 * @property {number} total - The total number of items in the response.
 * @property {number} count - The number of items in the response.
 * @property {number} offset - The offset of the items in the response.
 * @property {number} limit - The limit of the items in the response.
 * @property {T[]} items - The items in the response.
 */
interface PaginatedResponse<T> {
    total: number;
    count: number;
    offset: number;
    limit: number;
    items: T[];
}

type SearchParams = Record<string, string | number | boolean | undefined>;

declare enum SortBy {
    RELEVANCE = "RELEVANCE",
    DEFINED_BY_STORE_OWNER = "DEFINED_BY_STORE_OWNER",
    ADDED_TIME_DESC = "ADDED_TIME_DESC",
    ADDED_TIME_ASC = "ADDED_TIME_ASC",
    NAME_ASC = "NAME_ASC",
    NAME_DESC = "NAME_DESC",
    PRICE_ASC = "PRICE_ASC",
    PRICE_DESC = "PRICE_DESC",
    UPDATED_TIME_ASC = "UPDATED_TIME_ASC",
    UPDATED_TIME_DESC = "UPDATED_TIME_DESC"
}

declare const getApiConfig: () => ApiConfig;
declare const initStorefrontApi: (config: ApiConfig) => Promise<void>;

/** Detailed information about product's taxes. */
interface ProductTax {
    /** Defines if taxes can be applied to the product. */
    taxable: boolean;
    /** Default tax rate (%) for including into product price. It's a sum of all enabled taxes included in product price for the store location. Read only. */
    defaultLocationIncludedTaxRate: number;
    /** List of internal IDs for manual taxes. Empty if no manual taxes are enabled or automatic taxes are enabled. */
    enabledManualTaxes: number[];
    /** Tax class code for the product that determines the taxability of the products for a certain region. */
    taxClassCode: string;
}

/** Represents a wholesale price tier for a product or variation. */
interface WholesalePrice {
    /** Number of product items on this wholesale tier. */
    quantity: number;
    /** Product price on the tier. */
    price: number;
}

/** Product lowest price settings, typically for EU stores. */
interface LowestPriceSettings {
    /** Defines if the lowest price is enabled for the product and shown on the storefront. */
    lowestPriceEnabled: boolean;
    /** Manually entered lowest price for the last 30 days before any discounts or taxes applied. */
    manualLowestPrice?: number;
    /** manualLowestPrice with taxes applied. */
    defaultDisplayedManualLowestPrice?: number;
    /** Formatted display of defaultDisplayedManualLowestPrice using store format settings. */
    defaultDisplayedManualLowestPriceFormatted?: string;
    /** Automatically calculated lowest price for the last 30 days before any discounts or taxes applied. Read-only. */
    automaticLowestPrice?: number;
    /** automaticLowestPrice with taxes applied. Read-only. */
    defaultDisplayedAutomaticLowestPrice?: number;
    /** Formatted display of defaultDisplayedAutomaticLowestPrice using store format settings. Read-only. */
    defaultDisplayedAutomaticLowestPriceFormatted?: string;
}

/** Represents a choice for a product option, detailing its text and price modification. */
interface ProductOptionChoice {
    /** Text displayed for the option choice. */
    text: string;
    /** Available translations for the choice's text field. */
    textTranslated: Record<string, string>;
    /** Value of the option's price markup. */
    priceModifier: number;
    /** Option markup calculation type (PERCENT or ABSOLUTE). */
    priceModifierType: string;
}

/** Defines a product option, such as size or color, including its type, name, and available choices. */
interface ProductOption {
    /** Option type that defines its functionality.
     * One of: SELECT, RADIO, CHECKBOX, TEXTFIELD, TEXTAREA, DATE, FILES, SIZE, SWATCHES. */
    type: string;
    /** Product option name (e.g., Color or Size). */
    name: string;
    /** Available translations for product option name. */
    nameTranslated: Record<string, string>;
    /** List of available option choices for users.
     * Only works for SELECT, CHECKBOX, RADIO, SIZE, or SWATCHES option types. */
    choices?: ProductOptionChoice[];
    /** Index of the option's default selection. Can be null (no default option), otherwise starts with 0.
     * Only works for SELECT, CHECKBOX, RADIO, SIZE, or SWATCHES option types. */
    defaultChoice?: number;
    /** Defines if this option is required to add product to the cart. */
    required?: boolean;
}

/** Shipping settings specific to the product. */
interface ProductShipping {
    /** Type of shipping calculation.
     * One of: "GLOBAL_METHODS", "SELECTED_METHODS", "FLAT_RATE", "FREE_SHIPPING". */
    type: string;
    /** Additional product shipping cost added to any shipping methods. */
    methodMarkup: number;
    /** Flat rate cost for shipping the product. If set, shipping costs for it will not be calculated. */
    flatRate: number;
    /** IDs of shipping methods that need to be excluded from calculation when this product is in cart. */
    disabledMethods: string[];
    /** IDs of shipping methods which will only be shown when this product is in cart. */
    enabledMethods: string[];
}

/** Details about a product image, typically the main image. */
interface ProductImage {
    /** Link to the full-size product image. */
    url: string;
    /** Width of the full-size product image in px. */
    width: number;
    /** Height of the full-size product image in px. */
    height: number;
}

interface ProductColor {
    /** Red channel (from 0 to 255, RGB). */
    red: number;
    /** Green channel (from 0 to 255, RGB). */
    green: number;
    /** Blue channel (from 0 to 255, RGB). */
    blue: number;
    /** Alpha channel (from 0 to 255). */
    alpha: number;
}

/** Details about an image border added at the storefront, including its dominating color and homogeneity. */
interface ProductBorderInfo {
    /** Border color in RGBa format. */
    dominatingColor: ProductColor;
    /** Defines if an image is homogeneous. */
    homogeneity: boolean;
}

interface ProductGalleryImage {
    id: number;
    url: string;
    /** Link to the gallery image thumbnail resized to fit 160x160px container. */
    thumbnail: string;
    /** Link to the full-sized gallery image. */
    originalImageUrl: string;
    /** Link to the gallery image resized to fit 1200x1200px container. */
    imageUrl: string;
    /** Link to the gallery image thumbnail resized to fit 800x800px container. */
    hdThumbnailUrl: string;
    /** Link to the gallery image thumbnail resized to fit 400x400px container. */
    thumbnailUrl: string;
    /** Link to the gallery image thumbnail resized to fit 160x160px container. */
    smallThumbnailUrl: string;
    /** Width of the full-sized gallery image in px. */
    width: number;
    /** Height of the full-sized gallery image in px. */
    height: number;
    /** Consecutive number of an image in the gallery. Starts with 0. */
    orderBy: number;
    /** Details about image border added at the storefront. */
    borderInfo: ProductBorderInfo;
}

/** Represents the alt text for a product image, including translations. */
interface ProductImageAlt {
    /** Image description for the "alt" HTML attribute of the image. */
    main?: string;
    /** Available translations for the "alt" text. */
    translated: Record<string, string>;
}

/** Details about a product image within the media collection. */
interface ProductMediaImage {
    /** Internal image ID in a string format. Starts with "0". */
    id: string;
    /** Defines the main product image (if true). */
    isMain: boolean;
    /** Consecutive number of an image in the gallery. */
    orderBy: number;
    /** Link to the product image resized to fit 160x160px. */
    image160pxUrl: string;
    /** Link to the product image resized to fit 400x400px. */
    image400pxUrl: string;
    /** Link to the product image resized to fit 800x800px. */
    image800pxUrl: string;
    /** Link to the product image resized to fit 1500x1500px. */
    image1500pxUrl: string;
    /** Link to the full-sized product image. */
    imageOriginalUrl: string;
    /** Image description for the "alt" HTML attribute and its translations. */
    alt: ProductImageAlt;
}

/** Details about a product video within the media collection. */
interface ProductMediaVideo {
    /** Internal video ID. Starts with "0". */
    id: number;
    /** Internal ID of the video cover image. */
    videoCoverId: number;
    /** Link to the video file. */
    url: string;
    /** Video embedding code in HTML. */
    embedHtml: string;
    /** Video hosting provider name. */
    providerName: string;
    /** Video title. */
    title: string;
    /** Link to the video cover image resized to fit 160x160px container. */
    image160pxUrl: string;
    /** Link to the video cover image resized to fit 400x400px container. */
    image400pxUrl: string;
    /** Link to the video cover image resized to fit 800x800px container. */
    image800pxUrl: string;
    /** Link to the video cover image resized to fit 1500x1500px container. */
    image1500pxUrl: string;
    /** Link to the full-sized video cover image. */
    imageOriginalUrl: string;
}

/** Contains details about product images and videos. */
interface ProductMedia {
    /** Details about product images. */
    images: ProductMediaImage[];
    /** Details about product videos. */
    videos: ProductMediaVideo[];
}

/** Represents a category a product belongs to, including its ID and enabled status. */
interface ProductCategory {
    /** Internal category ID. */
    id: number;
    /** Defines if the category is enabled. */
    enabled: boolean;
}

/** Stats showing how many times the product was added to favorites on the storefront. */
interface ProductFavorites {
    /** Total count the product was added to favorites on the storefront. */
    count: number;
    /** The number of likes visible on the storefront. May differ from count if it exceeds 1000 (e.g., 1K). */
    displayedCount: string;
}

/** Represents a product attribute and its value. */
interface ProductAttribute {
    /** Internal attribute ID. */
    id: number;
    /** Attribute name visible on the storefront. */
    name: string;
    /** Available translations for the attribute name. */
    nameTranslated: Record<string, string>;
    /** Value of the attribute for this product. */
    value: string;
    /** Available translations for the attribute value. */
    valueTranslated: Record<string, string>;
    /** Attribute type (e.g., CUSTOM, UPC, BRAND).
     * One of: CUSTOM, UPC, BRAND, GENDER, AGE_GROUP, COLOR, SIZE, PRICE_PER_UNIT, UNITS_IN_PRODUCT. */
    type: string;
    /** Defines if an attribute is visible on a product page.
     * One of: NOTSHOW, DESCR, PRICE. */
    show: string;
}

/** Details about a downloadable file attached to the product. */
interface ProductFile {
    /** Internal ID of the file attached to the product. */
    id: number;
    /** File name visible to clients. */
    name: string;
    /** File description visible to clients. */
    description: string;
    /** File size in bytes (64-bit integer). */
    size: number;
    /** Direct link to the file. Important: to download, append API access token. */
    adminUrl: string;
}

/** Describes the "N random related products from a category" option for related products. */
interface ProductRelatedCategory {
    /** Defines if the "N random related products from a category" option is enabled. */
    enabled: boolean;
    /** ID of the related category. Empty value means related products can be from any category. */
    categoryId: number;
    /** Number of random products from the given category. */
    productCount: number;
}

/** List of related products displayed as "You may also like" for a product. */
interface ProductRelatedProducts {
    /** List of related product IDs. */
    productIds: number[];
    /** Describes the "N random related products from a category" option. */
    relatedCategory: ProductRelatedCategory;
}

/** Product's dimensions for calculating shipping costs. */
interface ProductDimensions {
    /** Length of a product for calculating shipping costs. */
    length: number;
    /** Width of a product for calculating shipping costs. */
    width: number;
    /** Height of a product for calculating shipping costs. */
    height: number;
}

/** Represents a selected product option value that identifies a product variation. */
interface ProductCombinationOption {
    /** Name of the selected option. */
    name: string;
    /** Available translations for the product option name. */
    nameTranslated: Record<string, string>;
    /** Value of the selected option. */
    value: string;
    /** Available translations for the product option value. */
    valueTranslated: Record<string, string>;
}

/** Details about a product variation (combination of product options). */
interface ProductCombination {
    /** Internal ID for the product variation. */
    id: number;
    /** Ordered variation number displayed in Ecwid admin. Starts with 1. */
    combinationNumber: number;
    /** Set of selected product option values that identify this variation. */
    options: ProductCombinationOption[];
    /** Variation SKU. If empty, inherits the base product's SKU. */
    sku?: string;
    /** Link to the variation image resized to fit 400x400px container. */
    thumbnailUrl?: string;
    /** Link to the variation image resized to fit 1200x1200px container. */
    imageUrl?: string;
    /** Link to the variation image resized to fit 160x160px container. */
    smallThumbnailUrl?: string;
    /** Link to the variation image resized to fit 800x800px container. */
    hdThumbnailUrl?: string;
    /** Link to the full-sized variation image. */
    originalImageUrl?: string;
    /** Number of variation items in stock. Not returned if unlimited is true. */
    quantity?: number;
    /** Defines if the variation has unlimited stock. */
    unlimited?: boolean;
    /** Base variation price without any modifiers. */
    price?: number;
    /** Sorted list of wholesale price tiers specific to the variation. */
    wholesalePrices?: WholesalePrice[];
    /** Variation's weight for calculating shipping costs. */
    weight?: number;
    /** Minimum amount of variation in stock to trigger "low stock" notification. */
    warningLimit?: number;
    /** List of variation attributes and their values. */
    attributes?: ProductAttribute[];
    /** Pre-sale price for the variation. */
    compareToPrice?: number;
    /** Sets minimum product purchase quantity. Default is null. */
    minPurchaseQuantity?: number;
    /** Sets maximum product purchase quantity. Default is null. */
    maxPurchaseQuantity?: number;
    /** Defines visibility/pre-order behavior when out-of-stock. One of: SHOW, HIDE, ALLOW_PREORDER. */
    outOfStockVisibilityBehaviour?: string;
    /** Variation price for logged out customers with default location. Includes taxes. */
    defaultDisplayedPrice?: number;
    /** Formatted variant of defaultDisplayedPrice. */
    defaultDisplayedPriceFormatted?: string;
    /** Variation's lowest price for EU store. */
    lowestPrice?: number;
    /** Variation's lowest price for logged out customers with default location. Includes taxes. */
    defaultDisplayedLowestPrice?: number;
    /** Formatted variant of defaultDisplayedLowestPrice. */
    defaultDisplayedLowestPriceFormatted?: string;
    /** Variation's lowest price settings. Defines if lowest price is enabled. */
    lowestPriceSettings?: LowestPriceSettings;
    /** Variation's dimensions. */
    dimensions?: ProductDimensions;
    /** Variation volume for calculations shipping costs, fractional number, 0 by default. */
    volume?: number;
    /** Variation image description for the "alt" HTML attribute and its translations. */
    alt?: ProductImageAlt;
}

/** Internal details on recurring charges for product subscriptions. */
interface ProductRecurringChargeSettings {
    /** Charge recurring interval. Supported values: DAY, WEEK, MONTH, YEAR. */
    recurringInterval: 'DAY' | 'WEEK' | 'MONTH' | 'YEAR';
    /** Charge recurring interval count.
     * Supported values: for DAY - 1 (daily), for WEEK - 1 (weekly), 2 (biweekly),
     * for MONTH - 1 (monthly), 3 (quarterly), for YEAR - 1 (annually). */
    recurringIntervalCount: number;
}

/** Internal details for subscription products. */
interface ProductSubscriptionSettings {
    /** true if the product can be sold as subscription. */
    subscriptionAllowed: boolean;
    /** true if the product can be purchased once. */
    oneTimePurchaseAllowed: boolean;
    /** The cost of the product by subscription with a one-time purchase, null by default. */
    oneTimePurchasePrice?: number | null;
    /** Formatted cost of the product for a one-time purchase. */
    oneTimePurchasePriceFormatted?: string;
    /** Difference between subscription price and one-time purchase price (absolute). */
    oneTimePurchaseMarkup?: number;
    /** Formatted difference (absolute). */
    oneTimePurchaseMarkupFormatted?: string;
    /** Difference between subscription price and one-time purchase price (percentage). */
    oneTimePurchaseMarkupPercent?: number;
    /** Formatted difference (percentage). */
    oneTimePurchaseMarkupPercentFormatted?: string;
    /** Recurring charge settings. */
    recurringChargeSettings?: ProductRecurringChargeSettings[];
    /** The cost of the product for the first subscription order. */
    subscriptionPriceWithSignUpFee?: number;
    /** Formatted cost for the first subscription order. */
    subscriptionPriceWithSignUpFeeFormatted?: string;
    /** The size of the markup that is imposed on the first order. */
    signUpFee?: number;
    /** Formatted size of the markup for the first order. */
    signUpFeeFormatted?: string;
}

/** Represents a product in an Ecwid store. */
interface Product {
    /** Internal unique product ID. */
    id: number;
    /** Product SKU. Items with options can have several SKUs specified in the product variations. */
    sku: string;
    /** Amount of product items in stock. If product has unlimited stock, this field is not returned. */
    quantity?: number;
    /** Defines if the product has unlimited stock. */
    unlimited: boolean;
    /** Defines if the product or any of its variations are in stock (quantity > 0). */
    inStock: boolean;
    /** Product name visible on the storefront. */
    name: string;
    /** Available translations for the product name. */
    nameTranslated: Record<string, string>;
    /** Base product price without any modifiers. */
    price: number;
    /** Product price as shown on storefront (may differ from price due to pre-selected options/variations). Does not include taxes. */
    priceInProductList: number;
    /** Product price as shown on storefront for logged out customers with default location. Includes taxes. */
    defaultDisplayedPrice: number;
    /** Formatted variant of defaultDisplayedPrice. */
    defaultDisplayedPriceFormatted: string;
    /** Purchase price of the product, used for reports and profit calculations. */
    costPrice?: number;
    /** Detailed information about product's taxes. */
    tax: ProductTax;
    /** Sorted list of wholesale price tiers. */
    wholesalePrices?: WholesalePrice[];
    /** Product pre-sale price (without taxes). */
    compareToPrice?: number;
    /** Formatted display of compareToPrice (with currency symbol, includes taxes if store uses net prices). */
    compareToPriceFormatted?: string;
    /** Discount from the sale price. */
    compareToPriceDiscount?: number;
    /** Formatted discount from the sale price. */
    compareToPriceDiscountFormatted?: string;
    /** Discount percent from the sale price. */
    compareToPriceDiscountPercent?: number;
    /** Formatted sale price discount percent. */
    compareToPriceDiscountPercentFormatted?: string;
    /** Product pre-sale price including taxes. */
    defaultDisplayedCompareToPrice?: number;
    /** Formatted display of defaultDisplayedCompareToPrice (with currency symbol, includes taxes if store uses net prices). */
    defaultDisplayedCompareToPriceFormatted?: string;
    /** Discount from the sale price, including taxes. */
    defaultDisplayedCompareToPriceDiscount?: number;
    /** Formatted discount from the sale price, including taxes. */
    defaultDisplayedCompareToPriceDiscountFormatted?: string;
    /** Discount percent from the sale price, including taxes. */
    defaultDisplayedCompareToPriceDiscountPercent?: number;
    /** Formatted sale price discount percent, including taxes. */
    defaultDisplayedCompareToPriceDiscountPercentFormatted?: string;
    /** Product's lowest price (before taxes and discounts) in the last 30 days. */
    lowestPrice?: number;
    /** Product's lowest price as displayed on storefront for default location (includes taxes). */
    defaultDisplayedLowestPrice?: number;
    /** Formatted display of defaultDisplayedLowestPrice. */
    defaultDisplayedLowestPriceFormatted?: string;
    /** Product lowest price settings for EU stores. */
    lowestPriceSettings?: LowestPriceSettings;
    /** Defines if the product requires shipping. */
    isShippingRequired: boolean;
    /** Product weight in units defined in store settings. Not returned if product has no weight. */
    weight?: number;
    /** Link to the product details page on the storefront. */
    url: string;
    /** Page slug generated for the product page URL automatically. */
    autogeneratedSlug: string;
    /** Custom slug defined by the store owner. Affects product page URL. */
    customSlug: string;
    /** Datetime of the product creation (e.g., 2024-07-30 10:32:37 +0000). */
    created: string;
    /** Datetime of the latest product change (e.g., 2024-07-30 10:32:37 +0000). */
    updated: string;
    /** UNIX timestamp of the product creation. */
    createTimestamp: number;
    /** UNIX timestamp of the latest product change. */
    updateTimestamp: number;
    /** ID of the product class. 0 for default "General" class. */
    productClassId: number;
    /** Defines if the product is enabled and visible on the storefront. */
    enabled: boolean;
    /** Detailed list of product options. Empty array if no options are specified. */
    options: ProductOption[];
    /** Minimum amount of products in stock to trigger a "low stock" email notification. */
    warningLimit?: number;
    /** Legacy. True if shipping cost is 'Fixed rate per item'. See 'shipping' field instead. */
    fixedShippingRateOnly: boolean;
    /** Legacy. Product fixed shipping cost per item or extra shipping cost. See 'shipping' field instead. */
    fixedShippingRate: number;
    /** Shipping settings specific to the product. */
    shipping: ProductShipping;
    /** Identifier of the default product variation. */
    defaultCombinationId: number;
    /** Details about product main image. */
    originalImage: ProductImage;
    /** Product description in HTML format. Scripts are not supported. */
    description: string;
    /** Available translations for the product description. */
    descriptionTranslated: Record<string, string>;
    /** Details about product gallery images. */
    galleryImages: ProductGalleryImage[];
    /** Details about product images and videos. */
    media: ProductMedia;
    /** List of the category IDs the product belongs to. */
    categoryIds: number[];
    /** Detailed list of the categories the product belongs to. */
    categories: ProductCategory[];
    /** Default category ID of the product. 0 if no default category. */
    defaultCategoryId: number;
    /** Page title for search engines. Recommended length < 55 chars. */
    seoTitle: string;
    /** Translations for the SEO page title. */
    seoTitleTranslated: Record<string, string>;
    /** Page description for search engines. Recommended length < 160 chars. */
    seoDescription: string;
    /** Translations for the SEO page description. */
    seoDescriptionTranslated: Record<string, string>;
    /** Stats showing how many times the product was added to favorites. */
    favorites: ProductFavorites;
    /** List of product attributes and their values. */
    attributes: ProductAttribute[];
    /** Details about downloadable files attached to the product. */
    files: ProductFile[];
    /** List of related products displayed as "You may also like". */
    relatedProducts: ProductRelatedProducts;
    /** Details about product variations. */
    combinations: ProductCombination[];
    /** Product's dimensions. */
    dimensions: ProductDimensions;
    /** Shipping preparation time settings. Structure might vary. */
    shippingPreparationTime?: Record<string, unknown>;
    /** Whether to show delivery time in the storefront. */
    showDeliveryTimeInStorefront?: boolean;
    /** Product volume for calculations shipping costs, fractional number, 0 by default. */
    volume: number;
    /** Product index on the main storefront page starting with 1. */
    showOnFrontpage?: number;
    /** Defines sample product created by Ecwid. Sample products are unavailable for purchase. */
    isSampleProduct: boolean;
    /** Condition of the item for Google Shopping (e.g., new, used, refurbished). */
    googleItemCondition?: string;
    /** Defines if a product is a gift card. */
    isGiftCard: boolean;
    /** Defines if Ecwid can apply discounts to the product. */
    discountsAllowed: boolean;
    /** Defines if customers can set their own price for the product. */
    nameYourPriceEnabled: boolean;
    /** Internal details for subscription products. */
    subscriptionSettings: ProductSubscriptionSettings;
    /** Google Product Category ID. */
    googleProductCategory?: number;
    /** Google Product Category name. */
    googleProductCategoryName?: string;
    /** Condition of the product (e.g., NEW, USED, REFURBISHED). */
    productCondition?: string;
    /** Defines behavior for out-of-stock products (SHOW, HIDE, ALLOW_PREORDER). */
    outOfStockVisibilityBehaviour?: string;
    /** Small product description visible under the product title. */
    subtitle?: string;
    /** Available translations for product subtitles. */
    subtitleTranslated?: Record<string, string>;
    /** When true, allows to collect, check, and publish reviews for this product. */
    reviewsCollectingAllowed?: boolean;
    /** Average rating from product reviews. */
    rating?: number;
    /** Number of reviews published by the store owner. */
    reviewsPublished?: number;
    /** Number of reviews waiting for store owner's approval. */
    reviewsModerated?: number;
}

/**
 * Response type for the searchProducts request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/search-products#response-json
 */
type SearchProductsResponse = PaginatedResponse<Product>;
/**
 * Parameters for the searchProducts request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/search-products#query-params
 */
interface SearchProductsParams extends SearchParams {
    /** Ecwid store ID. */
    storeId?: number;
    /** Internal IDs of Ecwid products separated by a comma.
     * If this field is specified, other search parameters are ignored. */
    productId?: string;
    /** Product or variation SKU. Ecwid will return details of a product containing that SKU, if SKU value is an exact match.
     * If SKU is specified, other search parameters are ignored, except for product ID. */
    sku?: string;
    /** Search term. Add * at the end of the keyword to disable the exact match search.
     * Search supports any language enabled in the store and specified in the lang param.
     * Supported fields:
     * - name
     * - description
     * - SKU (including variations SKU)
     * - options
     * - category name
     * - gallery image descriptions
     * - attributes values (except for hidden attributes). Any special characters must be URI-encoded. */
    keyword?: string;
    /** Extension to keyword.
     * One of:
     * - STOREFRONT – emulates search on the storefront
     * - CP – emulates search in Ecwid admin */
    searchMethod?: 'STOREFRONT' | 'CP';
    /** Product ID in linked POS. Includes both product IDs and product variation IDs.
     * Search term for product ID from the connected POS system (Lightspeed X/R series). */
    externalReferenceId?: string;
    /** Search term for finding products assigned to a specific category by its ID. */
    category?: number;
    /** Search term for finding products assigned to specified category IDs. For example: 0,123456,138470508. */
    categories?: string;
    /** Set true to get products from the subcategories of specified categories. */
    includeProductsFromSubcategories?: boolean;
    /** Minimum product price. */
    priceFrom?: number;
    /** Maximum product price. */
    priceTo?: number;
    /** Product creation date/time (lower bound). Supported formats: UNIX timestamp, datetime.
     * Examples: 1447804800, 2023-01-15 19:27:50 */
    createdFrom?: string | number;
    /** Product creation date/time (upper bound). Supported formats: UNIX timestamp, datetime.
     * Examples: 1447804800, 2023-01-15 19:27:50 */
    createdTo?: string | number;
    /** Product update date/time (lower bound). Supported formats: UNIX timestamp, date/time.
     * Examples: 1447804800, 2023-01-15 19:27:50 */
    updatedFrom?: string | number;
    /** Product update date/time (upper bound). Supported formats: UNIX timestamp, date/time.
     * Examples: 1447804800, 2023-01-15 19:27:50 */
    updatedTo?: string | number;
    /** Sort order for found products.
     * One of:
     * - RELEVANCE (default)
     * - DEFINED_BY_STORE_OWNER
     * - ADDED_TIME_DESC
     * - ADDED_TIME_ASC
     * - NAME_ASC
     * - NAME_DESC
     * - PRICE_ASC
     * - PRICE_DESC
     * - UPDATED_TIME_ASC
     * - UPDATED_TIME_DESC
     * When category search term is set, DEFINED_BY_STORE_OWNER is used automatically. */
    sortBy?: SortBy;
    /** Set true to get only enabled products.
     * Set false to get only disabled products. */
    enabled?: boolean;
    /** Set true to get gift cards only.
     * Set false to receive gift cards only. */
    isGiftCard?: boolean;
    /** Set true to get only in-stock products.
     * Set false to get only out-of-stock products. */
    inStock?: boolean;
    /** Set true to get only products with allowed discounts.
     * Set false to get only products where discounts are not allowed. */
    discountsAllowed?: boolean;
    /** Set true to get only products visible on the storefront.
     * Set false to get only hidden products. */
    visibleInStorefront?: boolean;
    /** Set true to get only products with customer-defined prices.
     * Set false to get only products without customer-defined prices. */
    isCustomerSetPrice?: boolean;
    /** Set onsale to get only items currently on sale.
     * Set onsale to get only items currently on sale.
     * Set notonsale to get only items currently not on sale. */
    onsale?: 'onsale' | 'notonsale';
    /** Set instock to get only in-stock products.
     * Set outofstock to get only out-of-stock products. */
    inventory?: 'instock' | 'outofstock';
    /** Set base URL for URLs in response.
     * If not specified, Ecwid will use the main URL from store settings. */
    baseUrl?: string;
    /** Set true to force receiving clean URLs – catalog links without hashbang (/#!/).
     * By default Ecwid checks if this setting is enabled for the store and responds with matching URLs. */
    cleanUrls?: boolean;
    /** Set true to receive product page slugs without IDs.
     * By default Ecwid checks if this setting is enabled for the store and responds with matching URLs. */
    slugsWithoutIds?: boolean;
    /** Offset from the beginning of the returned items list. Used when the response contains more items than limit allows to receive in one request.
     * Usually used to receive all items in several requests with multiple of a hundred, for example:
     * ?offset=0 for the first request,
     * ?offset=100, for the second request,
     * ?offset=200, for the third request, etc */
    offset?: number;
    /** Limit to the number of returned items. Maximum and default value (if not specified) is 100. */
    limit?: number;
    /** Limit JSON response by specific fields. If specified, all missing fields will be removed from the response body.
     * Example: ?responseFields=total,items(id,name,price,quantity) */
    responseFields?: string;
    /** Filter by product option name and one or several comma-separated values for that option.
     * A product will appear in the response if it has an option with a specified name that has any of the specified values.
     * For example, a product has an option named Size with three values 24, 26, and 30.
     * Then the following search term will find the product: option_Size=24,22.
     * Even when the product doesn't have an option value 22. */
    [key: `option_${string}`]: string | undefined;
    /** Filter by product attribute name and one or several comma-separated values for that attribute.
     * A product will appear in the response if it has an attribute with a specified name that has any of the specified values.
     * For example, a product has an attribute named Brand with an Ecwid value.
     * Then the following search term will find the product: attribute_Brand=Ecwid,Lightspeed.
     * Even when the product doesn't have a Lightspeed attribute value.
     */
    [key: `attribute_${string}`]: string | undefined;
}

/**
 * Search for products.
 *
 * @param {SearchProductsParams} params - The parameters for the searchProducts request.
 * @returns {Promise<SearchProductsResponse>} A promise that resolves to the search results.
 */
declare const searchProducts: (params?: SearchProductsParams) => Promise<SearchProductsResponse>;

/**
 * Response type for the getProduct request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/get-product#response-json
 */
type GetProductResponse = Product;
/**
 * Parameters for the getProduct request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/get-product#path-params
 */
interface GetProductParams {
    productId: number;
    baseUrl?: string;
    cleanUrls?: boolean;
    slugsWithoutIds?: boolean;
    lang?: string;
    responseFields?: string;
}

/**
 * Fetches a single product by its ID.
 *
 * @param {GetProductParams} params - The parameters for the getProduct request.
 * @returns {Promise<GetProductResponse>} A promise that resolves to the product details.
 */
declare const getProduct: (params: GetProductParams) => Promise<GetProductResponse>;

/**
 * The response from the downloadProductFile request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/product-files/download-product-file#response-json
 */
type DownloadProductFileResponse = Blob;
/**
 * The parameters for the downloadProductFile request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/products/product-files/download-product-file#query-params
 */
interface DownloadProductFileParams {
    storeId?: number;
    productId: number;
    fileId: number;
}

/**
 * Download a product file
 * @param {DownloadProductFileParams} params - The parameters for the downloadProductFile request.
 * @returns {Promise<DownloadProductFileResponse>} A promise that resolves to the download product file results.
 */
declare const downloadProductFile: (params: DownloadProductFileParams) => Promise<DownloadProductFileResponse>;

interface Category {
    id: number;
    name: string;
    enabled: boolean;
    description?: string;
    subcategories?: Category[];
    url?: string;
    imageUrl?: string;
    originalImageUrl?: string;
    thumbnail?: string;
    orderBy?: number;
    parentId?: number;
    productCount?: number;
}

/**
 * Response type for the searchCategories request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/categories/search-categories#response-json
 */
type SearchCategoriesResponse = PaginatedResponse<Category>;
/**
 * Parameters for the searchCategories request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/categories/search-categories#query-params
 */
interface SearchCategoriesParams {
    keyword?: string;
    parent?: number;
    parentIds?: string;
    withSubcategories?: boolean;
    hidden_categories?: boolean;
    offset?: number;
    limit?: number;
    lang?: string;
    responseFields?: string;
}

/**
 * Search categories in the store based on provided parameters.
 *
 * @param {SearchCategoriesParams} params - The parameters for the searchCategories request.
 * @returns {Promise<SearchCategoriesResponse>} A promise that resolves to the categories search results.
 */
declare const searchCategories: (params?: SearchCategoriesParams) => Promise<SearchCategoriesResponse>;

interface AccountBilling {
    planName: string;
    subscriptionFee: number;
    activeSubscriptionPeriod: string;
}

interface CurrencyFormat {
    code: string;
    symbol: string;
    symbolPosition: string;
    thousandsSeparator: string;
    decimalSeparator: string;
    decimalPlaces: number;
}

interface Account {
    accountEmail: string;
    accountName: string;
    accountId: number;
    accountCurrency: string;
    accountCurrencyFormat: CurrencyFormat;
    accountBilling: AccountBilling;
    availableFunctionality: string[];
}

interface Address {
    country: string;
    street: string;
    city: string;
    stateOrProvince: string;
    postalCode: string;
}

interface ApplePay {
    enabled: boolean;
    available: boolean;
}

interface DesignSettings {
    enable_catalog_on_one_page: boolean;
    product_list_image_size: string;
    product_list_show_product_images: boolean;
    product_list_product_info_layout: string;
    product_details_show_product_sku: boolean;
    product_details_layout: string;
    cart_widget_layout: string;
    show_footer_menu: boolean;
    show_breadcrumbs: boolean;
}

interface FeatureToggle {
    name: string;
    visible: boolean;
    enabled: boolean;
}

interface FilterSection {
    type: string;
    enabled: boolean;
    name?: string;
}

interface StarterSite {
    ecwidSubdomain: string;
    generatedUrl: string;
    customDomain: string;
}

interface GeneralInfo {
    storeId: number;
    email: string;
    creationDate: string;
    storeUrl: string;
    name: string;
    starterSite: StarterSite;
    storeLogoUrl: string;
    fbPixelId: string;
}

interface InstructionsForCustomer {
    instructionsTitle: string;
    instructions: string;
    instructionsTranslated: Record<string, string>;
}

interface LegalPage {
    type: string;
    enabled: boolean;
    title: string;
    titleTranslated: Record<string, string>;
    display: string;
    displayTranslated: Record<string, string>;
    text: string;
    textTranslated: Record<string, string>;
    externalUrl: string;
    externalUrlTranslated: Record<string, string>;
}

interface LegalPagesSettings {
    requireTermsAgreementAtCheckout: boolean;
    legalPages: LegalPage[];
}

interface NotificationSetting {
    enabled: boolean;
    marketingBlockEnabled?: boolean;
}

interface CustomerOrderMessages {
    orderConfirmation: NotificationSetting;
    orderStatusChanged: NotificationSetting;
    orderIsReadyForPickup: NotificationSetting;
    downloadEgoods: NotificationSetting;
    orderShipped: NotificationSetting;
    orderDelivered: NotificationSetting;
}
interface AdminMessages {
    newOrderPlaced: NotificationSetting;
    lowStockNotification: NotificationSetting;
}
interface MailNotifications {
    adminNotificationEmails: string[];
    customerNotificationFromEmail: string;
    customerOrderMessages: CustomerOrderMessages;
    adminMessages: AdminMessages;
}

interface OrderInvoiceSettings {
    invoiceLogoUrl: string;
    attachInvoiceToOrderEmailNotifications: string;
}

interface PaymentOption {
    id: string;
    enabled: boolean;
    configured: boolean;
    checkoutTitle: string;
    checkoutTitleTranslated: Record<string, string>;
    checkoutDescription: string;
    paymentProcessorId: string;
    paymentProcessorTitle: string;
    orderBy: number;
    appClientId: string;
    appNamespace: string;
    instructionsForCustomer: InstructionsForCustomer;
    methods: any[];
    paymentSurcharges?: {
        type: string;
        value: number;
    };
}

interface Payment {
    paymentOptions: PaymentOption[];
    applePay: ApplePay;
    applePayOptions: any[];
}

interface ProductFiltersSettings {
    enabledInStorefront: boolean;
    filterSections: FilterSection[];
}

interface RegistrationAnswers {
    alreadySelling: string;
    goods: string;
    forSomeone: string;
    website: string;
}

interface SalePrice {
    displayOnProductList: boolean;
    oldPriceLabel: string;
    oldPriceLabelTranslated: Record<string, string>;
    displayDiscount: string;
    displayLowestPrice: boolean;
}

interface ShippingZone {
    id: string;
    name: string;
    countries?: string[];
}

interface ShippingSettings {
    shippingZones: ShippingZone[];
}

interface SocialLinksSettings {
    facebook: Record<string, any>;
    instagram: Record<string, any>;
    twitter: Record<string, any>;
    youtube: Record<string, any>;
    vk: Record<string, any>;
    pinterest: Record<string, any>;
}

interface StoreSettings {
    storeName: string;
    storeEmail: string;
    storeDescription: string;
    storeTitle: string;
    invoiceLogoUrl: string;
    favIconUrl: string;
    checkoutHeaderLogoUrl: string;
    defaultLanguage: string;
    languages: string[];
    shippingOrigin: Address;
    askCompanyName: boolean;
    hideOutOfStockProductsInStorefront: boolean;
    orderCommentsCaption: string;
    orderCommentsRequired: boolean;
    orderCommentsCaptionTranslated: Record<string, string>;
    favoritesEnabled: boolean;
    defaultProductSortOrder: string;
    productSortOrderInCart: string;
    salePrice: SalePrice;
    showPricePerUnit: boolean;
    googleProductCategory: number;
    googleProductCategoryName: string;
    productCondition: string;
}

interface TaxInvoiceSettings {
    taxInvoiceLogoUrl: string;
    attachTaxInvoiceToOrderEmailNotifications: string;
    enableTaxInvoices: boolean;
    generateInvoicesAutomatically: string;
    taxInvoiceIdPrefix: string;
    taxInvoiceIdSuffix: string;
    taxInvoiceIdMinDigitsAmount: number;
    taxInvoiceIdNextNumber: number;
}

interface Tax {
    id: number;
    name: string;
    enabled: boolean;
    includeInPrice: boolean;
    useShippingAddress: boolean;
    taxShipping: boolean;
    appliedByDefault: boolean;
    defaultTax: number;
    rules: any[];
}

interface TaxSettings {
    automaticTaxEnabled: boolean;
    euIossEnabled: boolean;
    ukVatRegistered: boolean;
    taxes: Tax[];
    pricesIncludeTax: boolean;
    taxExemptBusiness: boolean;
    b2b_b2c: string;
    electronicInvoiceFieldsAtCheckoutEnabled: boolean;
    taxOnShippingCalculationScheme: string;
}

interface TipsSettings {
    enabled: boolean;
    type: string;
    options: number[];
    defaultOption: number;
    title: string;
    subTitle: string;
    titleTranslated: Record<string, string>;
    subtitleTranslated: Record<string, string>;
}

/**
 * Represents a store profile in the Ecwid API.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/store-profile/get-store-profile
 */
interface StoreProfile {
    generalInfo: GeneralInfo;
    account: Account;
    settings: StoreSettings;
    designSettings: DesignSettings;
    payment: Payment;
    shippingSettings: ShippingSettings;
    taxSettings: TaxSettings;
    mailNotifications: MailNotifications;
    productFiltersSettings: ProductFiltersSettings;
    orderInvoiceSettings: OrderInvoiceSettings;
    socialLinksSettings: SocialLinksSettings;
    registrationAnswers: RegistrationAnswers;
    tipsSettings: TipsSettings;
    taxInvoiceSettings: TaxInvoiceSettings;
    featureToggles: FeatureToggle[];
    legalPagesSettings: LegalPagesSettings;
}

/**
 * Response type for the getStoreProfile request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/store-profile/get-store-profile#response-json
 */
type GetStoreProfileResponse = StoreProfile;
/**
 * Parameters for the getStoreProfile request.
 * Based on: https://docs.ecwid.com/api-reference/rest-api/store-profile/get-store-profile#query-params
 */
interface GetStoreProfileParams {
    storeId?: number;
    /**
     * Set true to receive additional store profile data including account/billing data.
     * Requires read_store_profile_extended access scope.
     */
    showExtendedInfo?: boolean;
    /**
     * Language ISO code for translations in JSON response, e.g. en, fr.
     * Translates fields like: title, description, pickupInstruction, text, etc.
     */
    lang?: string;
    /**
     * Specify the exact fields to receive in response JSON.
     * If not specified, the response JSON will have all available fields for the entity.
     * Example: generalInfo(storeId,storeUrl)
     */
    responseFields?: string;
}

/**
 * Fetches the store profile.
 *
 * @param {GetStoreProfileParams} params - Optional parameters for the getStoreProfile request.
 * @returns {Promise<GetStoreProfileResponse>} A promise that resolves to the store profile.
 */
declare const getStoreProfile: (params?: GetStoreProfileParams) => Promise<GetStoreProfileResponse>;

export { type Account, type AccountBilling, type Address, type ApplePay, type Category, type CurrencyFormat, type DesignSettings, type DownloadProductFileParams, type DownloadProductFileResponse, type FeatureToggle, type FilterSection, type GeneralInfo, type GetProductParams, type GetProductResponse, type GetStoreProfileParams, type GetStoreProfileResponse, type InstructionsForCustomer, type LegalPage, type LegalPagesSettings, type LowestPriceSettings, type MailNotifications, type NotificationSetting, type OrderInvoiceSettings, type Payment, type PaymentOption, type Product, type ProductAttribute, type ProductBorderInfo, type ProductCategory, type ProductColor, type ProductCombination, type ProductCombinationOption, type ProductDimensions, type ProductFavorites, type ProductFile, type ProductFiltersSettings, type ProductGalleryImage, type ProductImage, type ProductImageAlt, type ProductMedia, type ProductMediaImage, type ProductMediaVideo, type ProductOption, type ProductOptionChoice, type ProductRecurringChargeSettings, type ProductRelatedCategory, type ProductRelatedProducts, type ProductShipping, type ProductSubscriptionSettings, type ProductTax, type RegistrationAnswers, type SalePrice, type SearchCategoriesParams, type SearchCategoriesResponse, type SearchProductsParams, type SearchProductsResponse, type ShippingSettings, type ShippingZone, type SocialLinksSettings, type StarterSite, type StoreProfile, type StoreSettings, type Tax, type TaxInvoiceSettings, type TaxSettings, type TipsSettings, type WholesalePrice, downloadProductFile, getApiConfig, getProduct, getStoreProfile, initStorefrontApi, searchCategories, searchProducts };