@viu/emporix-sdk 1.0.0

package/dist/product.d.cts

@@ -0,0 +1,400 @@
+import { C as ClientContext, b as AuthContext, P as PaginatedItems } from './context-vKgzZ-5f.cjs';
+
+/**
+ * Localized value which can have different structure which depends on provided `Content-Language` header.
+ */
+type LocalizedValue = string | {
+    [key: string]: string;
+};
+/**
+ * Indicates the product type, which is immutable. Once the product type is set, it cannot be updated.
+ *
+ */
+type ProductType = 'BASIC' | 'BUNDLE' | 'PARENT_VARIANT' | 'VARIANT' | 'DYNAMIC_VARIANT';
+/**
+ * Indicates the product type, which is immutable. This property is taken into account only for insert operations.
+ *
+ */
+type ProductTypeUpdate = 'BASIC' | 'BUNDLE' | 'PARENT_VARIANT' | 'VARIANT' | 'DYNAMIC_VARIANT';
+/**
+ * Indicates the template that has been used during the product creation. After assigning a template to the product, the new attributes can be defined under the `productTemplateAttributes` key in the `mixins` field. In case of variant attributes, the attributes should be defined under `productVariantAttributes`. The attributes are then validated in accordance with their definition in the template.
+ *
+ * **Note:** The template with defined variant attributes can be used only in PARENT_VARIANT and VARIANT types of product.
+ *
+ */
+type Template = {
+    /**
+     * Identifier of the product template.
+     */
+    id: string;
+    /**
+     * Product template version.
+     */
+    version: string;
+};
+/**
+ * List of bundled products
+ */
+type BundledProducts = Array<{
+    /**
+     * Identifier of the bundled product.
+     */
+    productId: string;
+    /**
+     * Amount of bundled products. Must be a positive number.
+     */
+    amount: number;
+}>;
+type Value = {
+    key?: string | number | boolean;
+};
+type Values = Array<Value>;
+/**
+ * This field contains all information about attributes and their values that are used for creating variants. It is presented in the form of a map, where 'key' is the name of the attribute and 'value' is the list of values of that attribute. The attributes and their values are based on their definitions in the `template` element assigned to the parent variant. Each attribute defined in the product template is flagged as a `variantAttribute`. Only the attributes that have this flag set as `true` can be used in the `variantAttributes` field.
+ */
+type VariantAttributes = {
+    [key: string]: Values;
+};
+/**
+ * In YaaS, a global resource identifier is a Uniform Resource Name (URN) with a custom YaaS schema and is called a YaaS Resource Name, or YRN.
+ *
+ * It is a unique identifier, which stores information about a resource, such as its type, ID or name of the tenant.
+ */
+type Yrn = string;
+/**
+ * Map of key-value pairs that associates tax classes with locations (countries). The key of the map should be specified as the existing location/country identifier (see the country-service). The value of the map entry should contain a tax class code (see the tax-service).
+ * Information about the association is required for price matching mechanism (see the price-service#MatchPrice).
+ */
+type TaxClasses = {
+    [key: string]: string;
+};
+/**
+ * Flag indicating whether the product has been published or not.
+ */
+type Published = boolean;
+/**
+ * Mixins request.
+ */
+type ProductMixins = {
+    [key: string]: unknown;
+};
+/**
+ * Metadata request.
+ */
+type ProductMetadataCore = {
+    /**
+     * Links to the mixin schemas.
+     */
+    mixins?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Metadata with the version information.
+ */
+type ProductMetadataWithVersion = ProductMetadataCore & {
+    /**
+     * Version of the document
+     */
+    version?: number;
+};
+/**
+ * Metadata for GET requests.
+ */
+type ProductMetadataGet = ProductMetadataWithVersion & {
+    /**
+     * List of mixin schemas used for classification.
+     */
+    classificationMixins?: Array<{
+        /**
+         * Name of the mixin
+         */
+        name?: string;
+        /**
+         * The mixins path that should be used when defining attributes on a product. It's built based on the following pattern - `class_<sourceCategory.code>_<name>`.
+         */
+        mixinPath?: string;
+        /**
+         * URL of the mixin schema defined on the category level.
+         */
+        schemaUrl?: string;
+        /**
+         * If given mixin has been already used in the product, then this field contains the URL of the used mixin schema.
+         */
+        usedSchemaUrl?: string;
+        /**
+         * Indicates whether the used mixin schema is obsolete - `usedSchemaUrl` differs from `schemaUrl`.
+         */
+        obsoleteSchemaUrlUsed?: boolean;
+        /**
+         * Indicates whether the mixin is required.
+         */
+        required?: boolean;
+        /**
+         * Unique identifier of the category from which the mixin comes from. Can be this category ID or one of the parent categories IDs.
+         */
+        sourceCategoryId?: string;
+    }>;
+    /**
+     * Creation date in the ISO 8601 standard.
+     */
+    createdAt?: string;
+    /**
+     * Modification date in the ISO 8601 standard.
+     */
+    modifiedAt?: string;
+};
+/**
+ * Unique resource identifier.
+ */
+type Id = string;
+/**
+ * Media files attached to the product.
+ */
+type ProductMedia = Array<{
+    id?: string;
+    yrn?: Yrn;
+    contentType?: string;
+    createdAt?: string;
+    uploadLink?: string;
+    url?: string;
+    cloudinaryUrl?: string;
+    uncommittedMedia?: boolean;
+    tags?: Array<string>;
+    customAttributes?: {
+        [key: string]: unknown;
+    };
+}>;
+type ProductCore = {
+    name?: LocalizedValue;
+    /**
+     * Unique product identifier, defined by the user.
+     */
+    code?: string;
+    description?: LocalizedValue;
+    vendor?: Vendor;
+    taxClasses?: TaxClasses;
+    published?: Published;
+    /**
+     * Mark the product as weight-dependent if the line item price could change after packaging, as this is necessary to ensure that credit card payments can be authorized.
+     */
+    weightDependent?: boolean;
+    mixins?: ProductMixins;
+    /**
+     * List of items in a relationship with the main product. Assuming that in the system the following relation types are defined: `ACCESSORY` and `CONSUMABLE`, the two products: `Printer` and `Ink` exist, then the `Ink` product can be used as a related item with type `CONSUMABLE` for the Printer product.
+     * In order to find all printers for which the ink is defined as a `CONSUMABLE` then `q-param` can be used:
+     * `products?q=relatedItems.type:CONSUMABLE relatedItems.refId:Ink_Id`
+     *
+     */
+    relatedItems?: Array<RelatedItem>;
+    /**
+     * ID of brand.
+     */
+    brandId?: string;
+    brand?: Brand;
+    /**
+     * Collection of label IDs.
+     */
+    labelIds?: Array<string>;
+    labels?: Array<Label>;
+};
+/**
+ * Brand data expanded from `brandId`.
+ */
+type Brand = {
+    id?: string;
+    name?: string;
+    description?: string;
+    localizedName?: {
+        [key: string]: string;
+    };
+    localizedDescription?: {
+        [key: string]: string;
+    };
+    image?: string;
+    cloudinaryUrl?: string;
+    mediaId?: string;
+};
+/**
+ * Overlay metadata for a label.
+ */
+type LabelOverlay = {
+    isTrue?: boolean;
+    position?: number;
+};
+/**
+ * Label data expanded from `labelIds`.
+ */
+type Label = {
+    id?: string;
+    name?: string;
+    description?: LocalizedValue;
+    image?: string;
+    cloudinaryUrl?: string;
+    mediaId?: string;
+    overlay?: LabelOverlay;
+};
+/**
+ * Products of the BASIC type.
+ */
+type BasicProduct = ProductCore & {
+    metadata?: ProductMetadataCore;
+    template?: Template;
+};
+/**
+ * Creating products of the BASIC type.
+ */
+type BasicProductCreation = BasicProduct & {
+    /**
+     * Custom product identifier. If not provided, it is automatically generated.
+     */
+    id?: string;
+    productType?: ProductType;
+};
+/**
+ * Products of the BASIC type.
+ */
+type BasicProductWithId = BasicProductCreation & {
+    id?: Id;
+    yrn?: Yrn;
+    media?: ProductMedia;
+    metadata?: ProductMetadataGet;
+    /**
+     * Customer segment IDs assigned to the product.
+     */
+    customerSegmentIds?: Array<string>;
+    /**
+     * Category IDs assigned to the product.
+     */
+    categoryIds?: Array<string>;
+};
+/**
+ * Products of the BUNDLE type.
+ */
+type BundleProduct = ProductCore & {
+    metadata?: ProductMetadataCore;
+    template?: Template;
+    bundledProducts: BundledProducts;
+    productType: ProductTypeUpdate;
+};
+/**
+ * Creating products of the BUNDLE type.
+ */
+type BundleProductCreation = BundleProduct & {
+    /**
+     * Custom product identifier. If not provided, it is automatically generated.
+     */
+    id?: string;
+    productType?: ProductType;
+};
+/**
+ * Products of the BUNDLE type.
+ */
+type BundleProductWithId = BundleProductCreation & {
+    id?: Id;
+    yrn?: Yrn;
+    media?: ProductMedia;
+    metadata?: ProductMetadataGet;
+    /**
+     * Customer segment IDs assigned to the product.
+     */
+    customerSegmentIds?: Array<string>;
+    /**
+     * Category IDs assigned to the product.
+     */
+    categoryIds?: Array<string>;
+};
+/**
+ * Products of the PARENT_VARIANT type.
+ */
+type ParentVariantProduct = ProductCore & {
+    metadata?: ProductMetadataCore;
+    template: Template;
+    variantAttributes: VariantAttributes;
+};
+/**
+ * Creating products of the PARENT_VARIANT type.
+ */
+type ParentVariantProductCreation = ParentVariantProduct & {
+    /**
+     * Custom product identifier. If not provided, it is automatically generated.
+     */
+    id?: string;
+    productType?: ProductType;
+};
+/**
+ * Products of the PARENT_VARIANT type.
+ */
+type ParentVariantProductWithId = ParentVariantProductCreation & {
+    id?: Id;
+    yrn?: Yrn;
+    media?: ProductMedia;
+    metadata?: ProductMetadataGet;
+    /**
+     * Customer segment IDs assigned to the product.
+     */
+    customerSegmentIds?: Array<string>;
+    /**
+     * Category IDs assigned to the product.
+     */
+    categoryIds?: Array<string>;
+};
+type Vendor = {
+    /**
+     * An identifier of a vendor to whom the product belongs.
+     */
+    id: string;
+    /**
+     * Vendor name.
+     */
+    name?: string;
+};
+type RelatedItem = {
+    /**
+     * Identifier of a product which is in the relationship with the main product. The product identifier has to exist.
+     */
+    refId: string;
+    /**
+     * A relation type. The type has to exist in the system. All relation types are defined in configuration service under `relation_types` key.
+     */
+    type: string;
+};
+
+/** A product as returned by the Product service (all generated fields). */
+type Product = BasicProductWithId | BundleProductWithId | ParentVariantProductWithId;
+/** A single product media entry (generated; `ProductMedia` is the list type). */
+type Media = ProductMedia[number];
+/** Catalog reads. Default auth: anonymous; pass customer for personalized pricing. */
+declare class ProductService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /** Fetches one product by id. */
+    get(productId: string, _opts?: Record<string, never>, auth?: AuthContext): Promise<Product>;
+    /** Fetches one product by its code. */
+    getByCode(code: string, auth?: AuthContext): Promise<Product>;
+    /** One page of products. */
+    list(params?: {
+        pageNumber?: number;
+        pageSize?: number;
+    }, auth?: AuthContext): Promise<PaginatedItems<Product>>;
+    /** Async-iterates every product across pages. */
+    listAll(params?: {
+        pageSize?: number;
+    }, auth?: AuthContext): AsyncIterable<Product>;
+    /** Searches products by free-text query. */
+    search(query: string, params?: {
+        pageNumber?: number;
+        pageSize?: number;
+    }, auth?: AuthContext): Promise<PaginatedItems<Product>>;
+    /**
+     * Bulk fetch by id. POSTs `/products/search` with `q="id:(id1,id2,…)"`,
+     * chunking when the list is larger than `options.chunkSize` (default
+     * 100). An empty list short-circuits with no HTTP call. **Order is not
+     * guaranteed** across chunks — re-index by `id` if order matters.
+     */
+    searchByIds(ids: string[], options?: {
+        chunkSize?: number;
+    }, auth?: AuthContext): Promise<Product[]>;
+}
+
+export { type Media, type Product, ProductService };