@viu/emporix-sdk 2.21.0 → 2.23.0

package/dist/product.d.cts

@@ -7,6 +7,94 @@ import { a as QueryFor } from './query-mLQs2WFr.cjs';
 type LocalizedValue = string | {
     [key: string]: string;
 };
+type ProductTemplateBase = {
+    /**
+     * Localized product template name in a form of a map of translations.
+     */
+    name: {
+        [key: string]: string;
+    };
+    /**
+     * List of attributes related to the product template.
+     */
+    attributes: Array<ProductTemplateAttribute>;
+};
+type ProductTemplateCreation = ProductTemplateBase & {
+    /**
+     * Identifier of the product template.
+     */
+    id?: string;
+};
+type ProductTemplateAttribute = {
+    /**
+     * An identifier of the attribute. The key is used as a field name in a product instance created based on the product template. The key can contain only alphanumeric characters.
+     */
+    key: string;
+    /**
+     * Localized resource name in a form of a map of translations.
+     */
+    name: {
+        [key: string]: string;
+    };
+    /**
+     * Attribute type. Correct values: `TEXT`, `NUMBER`, `BOOLEAN`, `DATETIME`. Regardless of the chosen type, the defaultValue and values fields are validated. The DATETIME values must be compliant with the ISO 8601 standard, for example: 2022-03-31T09:52:15.423Z.
+     */
+    type: string;
+    /**
+     * Metadata contains additional information about the attribute.
+     */
+    metadata: {
+        /**
+         * Indicates whether the attribute should be treated as a mandatory.
+         */
+        mandatory?: boolean;
+        /**
+         * Indicates whether the attribute is a variant-specific attribute. Variant attributes are taken into account during variants creation.
+         * If the value is set to true, then the 'values' array cannot be null.
+         */
+        variantAttribute?: boolean;
+        /**
+         * The attribute stores a default value for the attribute.
+         */
+        defaultValue?: string | boolean | number;
+    };
+    values?: Values & {
+        [key: string]: unknown;
+    };
+};
+type ProductTemplateMetadata = {
+    /**
+     * Schema url of the variant attributes.
+     */
+    variantAttributesSchema?: string;
+    /**
+     * Schema url of the template attributes.
+     */
+    templateAttributesSchema?: string;
+    /**
+     * Date and time when the object was created, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    createdAt?: string;
+    /**
+     * Date and time when the object was last modified, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    modifiedAt?: string;
+    /**
+     * Version of the object. The value is required during update operation.
+     */
+    version?: number;
+};
+type ProductTemplateResponse = ProductTemplateCreation & {
+    metadata?: ProductTemplateMetadata;
+};
+type ProductTemplateUpdate = ProductTemplateBase & {
+    metadata: {
+        /**
+         * Version of the object. The value is required while product template update.
+         */
+        version: number;
+    };
+};
 /**
  * Indicates the product type, which is immutable. Once the product type is set, it cannot be updated.
  *
@@ -56,6 +144,10 @@ type Values = Array<Value>;
 type VariantAttributes = {
     [key: string]: Values;
 };
+type ResourceLocation = {
+    id?: string;
+    yrn?: Yrn;
+};
 /**
  * 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.
  *
@@ -79,6 +171,12 @@ type Published = boolean;
 type ProductMixins = {
     [key: string]: unknown;
 };
+/**
+ * Mixins request.
+ */
+type ProductVariantMixins = {
+    [key: string]: unknown;
+};
 /**
  * Metadata request.
  */
@@ -145,6 +243,26 @@ type ProductMetadataGet = ProductMetadataWithVersion & {
      */
     modifiedAt?: string;
 };
+/**
+ * Metadata request.
+ */
+type VariantProductMetadataCore = ProductMetadataCore & {
+    /**
+     * By default, all variant products inherit their attributes from the parent variant. You need to include the name of the attribute in the `metadata.overridden` field to be able to replace the attribute values. For the `mixins` and `metadata` fields, you can provide a nested path so that only a single mixin attribute is overridden, for example `mixins.productCustomAttributes.pricingMeasurePrice`. The same rule is valid for providing the mixins schema, as you can override just this particular field with the provided schema, for example metadata.mixins.yourCustomAttributes.
+     *
+     * **Note:**You cannot override the following attributes: `id`, `code`, `template`, `variantAttributes`.
+     */
+    overridden?: Array<string>;
+};
+/**
+ * Metadata with the version information.
+ */
+type VariantProductMetadataWithVersion = VariantProductMetadataCore & {
+    /**
+     * Version of the document.
+     */
+    version?: number;
+};
 /**
  * Unique resource identifier.
  */
@@ -275,6 +393,19 @@ type BasicProductWithId = BasicProductCreation & {
      */
     categoryIds?: Array<string>;
 };
+/**
+ * Updating products of the BASIC type.
+ */
+type BasicProductUpdate = BasicProduct & {
+    metadata?: ProductMetadataWithVersion;
+    productType?: ProductTypeUpdate;
+};
+/**
+ * Updating products of the BASIC type in bulk.
+ */
+type BasicProductBulkUpdate = BasicProductUpdate & {
+    id: Id;
+};
 /**
  * Products of the BUNDLE type.
  */
@@ -311,6 +442,18 @@ type BundleProductWithId = BundleProductCreation & {
      */
     categoryIds?: Array<string>;
 };
+/**
+ * Updating products of the BUNDLE type.
+ */
+type BundleProductUpdate = BundleProduct & {
+    metadata?: ProductMetadataWithVersion;
+};
+/**
+ * Updating products of the BUNDLE type in bulk.
+ */
+type BundleProductBulkUpdate = BundleProductUpdate & {
+    id: Id;
+};
 /**
  * Products of the PARENT_VARIANT type.
  */
@@ -346,6 +489,217 @@ type ParentVariantProductWithId = ParentVariantProductCreation & {
      */
     categoryIds?: Array<string>;
 };
+/**
+ * Updating products of the PARENT_VARIANT type.
+ */
+type ParentVariantProductUpdate = ParentVariantProduct & {
+    metadata?: ProductMetadataWithVersion;
+    productType?: ProductTypeUpdate;
+};
+/**
+ * Updating products of the PARENT_VARIANT type in bulk.
+ */
+type ParentVariantProductBulkUpdate = ParentVariantProductUpdate & {
+    id: Id;
+};
+/**
+ * Products of the VARIANT type.
+ */
+type VariantProduct = ProductCore & {
+    mixins?: ProductVariantMixins;
+};
+/**
+ * Creating products of the VARIANT type.
+ */
+type VariantProductCreation = VariantProduct & {
+    /**
+     * Custom product identifier. If not provided, it is automatically generated.
+     */
+    id?: string;
+    metadata?: VariantProductMetadataCore;
+    /**
+     * Identifier of the PARENT_VARIANT product.
+     */
+    parentVariantId?: string;
+    productType?: ProductType;
+};
+/**
+ * Updating products of the VARIANT type.
+ */
+type VariantProductUpdate = VariantProduct & {
+    metadata?: VariantProductMetadataWithVersion;
+    productType?: ProductTypeUpdate;
+    /**
+     * Identifier of the PARENT_VARIANT product. This property is taken into account only for insert operations.
+     */
+    parentVariantId?: string;
+};
+/**
+ * Updating products of the VARIANT type in bulk.
+ */
+type VariantProductBulkUpdate = VariantProductUpdate & {
+    id: Id;
+};
+/**
+ * The value part of a dynamic variant attribute. Holds the canonical qualifier used for matching, an optional localized display label, and an optional unit code for measurement attributes.
+ *
+ */
+type DynamicVariantAttributeValue = {
+    /**
+     * Data type of the qualifier value.
+     *
+     */
+    type: 'STRING' | 'NUMBER' | 'DECIMAL' | 'BOOLEAN';
+    /**
+     * The canonical value used for variant matching. The JSON type must match `type`: a string for `STRING`, a number for `NUMBER` or `DECIMAL`, or a boolean for `BOOLEAN`.
+     *
+     */
+    qualifier: string | number | boolean;
+    name?: LocalizedValue;
+    /**
+     * Optional unit code for measurement attributes (for example, `"MMT"` for millimetres, `"PCE"` for pieces). Unit translations are resolved by the frontend from a separate dictionary.
+     *
+     */
+    unit?: string;
+};
+/**
+ * A single dynamic variant attribute. Combines a localized display name for the attribute itself with a typed, optionally localized value.
+ *
+ */
+type DynamicVariantAttribute = {
+    name?: LocalizedValue;
+    value: DynamicVariantAttributeValue;
+};
+/**
+ * Map of variant attributes defined directly on this product. Keys are attribute identifiers (for example, `storageCapacity`). These are the attributes the caller can set by create/update requests. On responses they represent what is stored on this specific product.
+ *
+ */
+type OwnVariantAttributes = {
+    [key: string]: DynamicVariantAttribute;
+};
+/**
+ * Base schema for products of the DYNAMIC_VARIANT type.
+ */
+type DynamicVariantProduct = ProductCore & {
+    metadata?: ProductMetadataCore;
+    /**
+     * Identifier of the immediate parent product in the variant hierarchy. Omit or leave empty for root-level dynamic variant products.
+     *
+     */
+    parentVariantId?: string;
+    /**
+     * Optional label identifying the variant level or kind within the hierarchy (for example, `"H1_L1"`). Used for display and filtering purposes.
+     *
+     */
+    dynamicVariantType?: string;
+    /**
+     * Indicates whether this variant can be sold directly, if it's a leaf in the hierarchy that a customer can add to a cart. This value is **not inherited** from parent variants — it must be set explicitly on each product. Root products and intermediate-level variants are typically `false`. Leaf variants are typically `true`.
+     *
+     */
+    sellable?: boolean;
+    ownVariantAttributes?: OwnVariantAttributes;
+};
+/**
+ * Creating products of the DYNAMIC_VARIANT type.
+ */
+type DynamicVariantProductCreation = DynamicVariantProduct & {
+    /**
+     * Custom product identifier. If not provided, it is automatically generated.
+     */
+    id?: string;
+    productType?: ProductType;
+};
+/**
+ * Updating products of the DYNAMIC_VARIANT type.
+ */
+type DynamicVariantProductUpdate = DynamicVariantProduct & {
+    metadata?: ProductMetadataWithVersion;
+    productType?: ProductTypeUpdate;
+};
+/**
+ * Updating products of the DYNAMIC_VARIANT type in bulk.
+ */
+type DynamicVariantProductBulkUpdate = DynamicVariantProductUpdate & {
+    id: Id;
+};
+/**
+ * Request body for triggering dynamic variant recalculation. Accepts up to 1000 product IDs at any level of the hierarchy — the system resolves the root for each ID automatically. Intended to be called after a batch of products has been fully ingested, not per individual product write.
+ *
+ */
+type DynamicVariantRecalculationRequest = {
+    /**
+     * List of product IDs (variants at any hierarchy level) for which recalculation should be triggered. The system groups IDs by their root product and creates one job per unique root.
+     *
+     */
+    productIds: Array<string>;
+};
+/**
+ * Current status of a dynamic variant recalculation job.
+ */
+type DynamicVariantRecalculationJobStatus = 'PENDING' | 'PROCESSING' | 'FINISHED' | 'FAILED' | 'FAILED_PERMANENT';
+/**
+ * Represents a single dynamic variant recalculation job. One job is created per unique root product. Jobs remain queryable until automatically removed approximately 30 days after reaching a terminal state.
+ *
+ */
+type DynamicVariantRecalculationJobResponse = {
+    /**
+     * Unique identifier of the recalculation job.
+     */
+    id?: string;
+    /**
+     * Identifier of the root product whose variant tree is being recalculated.
+     */
+    parentRoot?: string;
+    /**
+     * List of product IDs that were submitted in the recalculation request and resolved to this root.
+     */
+    requestedByIds?: Array<string>;
+    status?: DynamicVariantRecalculationJobStatus;
+    /**
+     * Timestamp when the job was created.
+     */
+    createdAt?: string;
+    /**
+     * Timestamp when a subscriber picked up the job and started processing. Null while the job is still PENDING.
+     */
+    processingStartedAt?: string;
+    /**
+     * Timestamp when the job reached a terminal state (FINISHED, FAILED, or FAILED_PERMANENT).
+     */
+    finishedAt?: string;
+    /**
+     * Error message if the job failed. Null for successful jobs.
+     */
+    error?: string;
+    /**
+     * Number of processing attempts made for this job. Incremented on each delivery from the pub/sub subscription.
+     */
+    attempts?: number;
+};
+/**
+ * Response returned when recalculation is triggered. Contains one job per unique root product resolved from the submitted IDs, plus any IDs that were skipped (for example, because a job for that root is already PENDING or PROCESSING).
+ *
+ */
+type DynamicVariantRecalculationResponse = {
+    /**
+     * List of recalculation jobs created or referenced for each unique root product.
+     */
+    jobs?: Array<DynamicVariantRecalculationJobResponse>;
+    /**
+     * Product IDs that were not processed because a recalculation job for their root is already active (PENDING or PROCESSING). The existing job ID is available in the `jobs` list.
+     *
+     */
+    skippedProductIds?: Array<string>;
+};
+/**
+ * Partially updating a product.
+ */
+type ProductPartialUpdate = ProductCore & {
+    template?: Template;
+    bundledProducts?: BundledProducts;
+    variantAttributes?: VariantAttributes;
+    metadata?: ProductMetadataWithVersion;
+};
 type Vendor = {
     /**
      * An identifier of a vendor to whom the product belongs.
@@ -366,11 +720,88 @@ type RelatedItem = {
      */
     type: string;
 };
+type BulkResponse = {
+    /**
+     * Index of the processed product, matching the price position in request body.
+     *
+     */
+    index?: number;
+    /**
+     * Product unique identifier.
+     */
+    id?: string;
+    /**
+     * HTTP Status Code.
+     */
+    code?: number;
+    /**
+     * Error specific errorCode.
+     */
+    errorCode?: string;
+    /**
+     * HTTP Status description.
+     */
+    status?: string;
+    /**
+     * Error message.
+     */
+    message?: string;
+    /**
+     * Error message details.
+     */
+    details?: Array<string>;
+};
+type ProductCreateBody = BasicProductCreation | BundleProductCreation | ParentVariantProductCreation | VariantProductCreation | DynamicVariantProductCreation;
+type ProductUpdateBody = BasicProductUpdate | BundleProductUpdate | ParentVariantProductUpdate | VariantProductUpdate | DynamicVariantProductUpdate;
+type ProductPartialUpdateBody = ProductPartialUpdate;
+type ProductBulkUpdateBody = Array<BasicProductBulkUpdate | BundleProductBulkUpdate | ParentVariantProductBulkUpdate | VariantProductBulkUpdate | DynamicVariantProductBulkUpdate>;
+/**
+ * A list of product create requests
+ */
+type ProductBulkCreateBody = Array<BasicProductCreation | BundleProductCreation | ParentVariantProductCreation | VariantProductCreation | DynamicVariantProductCreation>;
 
 /** 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];
+/** Body for creating a product (`POST /products`) — any of the 5 product shapes. */
+type ProductCreateInput = ProductCreateBody;
+/** Body for a full product replace (`PUT /products/{id}`). */
+type ProductUpdateInput = ProductUpdateBody;
+/** Body for a partial product update (`PATCH /products/{id}`). */
+type ProductPatchInput = ProductPartialUpdateBody;
+/** Id/location envelope returned when a product is created. */
+type ProductCreated = ResourceLocation;
+/** Body for bulk-creating products (`POST /products/bulk`). */
+type ProductBulkCreateInput = ProductBulkCreateBody;
+/** Body for bulk-updating products (`PUT /products/bulk`). */
+type ProductBulkUpdateInput = ProductBulkUpdateBody;
+/** Per-entry result of a bulk product operation (207 Multi-Status). */
+type ProductBulkResult = BulkResponse;
+/** Body for triggering a dynamic-variant recalculation. */
+type ProductRecalculationInput = DynamicVariantRecalculationRequest;
+/** Result of triggering a recalculation — created jobs plus skipped product ids. */
+type ProductRecalculationResult = DynamicVariantRecalculationResponse;
+/** A dynamic-variant recalculation job. */
+type ProductRecalculationJob = DynamicVariantRecalculationJobResponse;
+/** Status of a recalculation job. */
+type ProductRecalculationJobStatus = DynamicVariantRecalculationJobStatus;
+/** A product template as returned by the Product service. */
+type ProductTemplate = ProductTemplateResponse;
+/** Body for creating a product template. */
+type ProductTemplateCreateInput = ProductTemplateCreation;
+/** Body for updating a product template (`PUT`, full replace). */
+type ProductTemplateUpdateInput = ProductTemplateUpdate;
+/** Id envelope returned when a product template is created. */
+type ProductTemplateCreated = {
+    id?: string;
+};
+/** Query flags shared by the product write endpoints. */
+interface ProductWriteOptions {
+    skipVariantGeneration?: boolean;
+    doIndex?: boolean;
+    skipRelatedItemsValidation?: boolean;
+}
 /** Catalog reads. Default auth: anonymous; pass customer for personalized pricing. */
 declare class ProductService {
     private readonly ctx;
@@ -447,6 +878,77 @@ declare class ProductService {
     listVariantChildren(parentVariantId: string, params?: {
         pageSize?: number;
     }, auth?: AuthContext): Promise<Product[]>;
+    /**
+     * Creates a product (`POST /products`). Default auth: service. Accepts any of
+     * the five product shapes (basic, bundle, parent-variant, variant,
+     * dynamic-variant).
+     */
+    create(input: ProductCreateInput, options?: ProductWriteOptions, auth?: AuthContext): Promise<ProductCreated>;
+    /**
+     * Partially updates a product (`PATCH /products/{productId}`). Default auth:
+     * service. Use {@link replace} for a full replace (PUT).
+     */
+    update(productId: string, input: ProductPatchInput, options?: ProductWriteOptions, auth?: AuthContext): Promise<void>;
+    /**
+     * Full-replaces a product (`PUT /products/{productId}`). Returns the created
+     * resource on 201 (upsert) and nothing on 204. `options.partial` sends
+     * `?partial=true` for a merge-style replace. Default auth: service.
+     */
+    replace(productId: string, input: ProductUpdateInput, options?: ProductWriteOptions & {
+        partial?: boolean;
+    }, auth?: AuthContext): Promise<ProductCreated | void>;
+    /**
+     * Deletes a product (`DELETE /products/{productId}`). `options.force` deletes
+     * even when the product is referenced. Default auth: service.
+     */
+    delete(productId: string, options?: {
+        force?: boolean;
+        doIndex?: boolean;
+    }, auth?: AuthContext): Promise<void>;
+    /**
+     * Bulk-creates products (`POST /products/bulk`). Responds 207 Multi-Status:
+     * partial failures do **not** throw — inspect each entry. Default auth: service.
+     */
+    bulkCreate(input: ProductBulkCreateInput, options?: ProductWriteOptions, auth?: AuthContext): Promise<ProductBulkResult[]>;
+    /**
+     * Bulk-updates products (`PUT /products/bulk`). Responds 207 Multi-Status:
+     * partial failures do **not** throw — inspect each entry. Default auth: service.
+     */
+    bulkUpdate(input: ProductBulkUpdateInput, options?: ProductWriteOptions, auth?: AuthContext): Promise<ProductBulkResult[]>;
+    /**
+     * Triggers a dynamic-variant recalculation for the given product ids
+     * (`POST /products/recalculate`, 202). The result carries the created or
+     * already-referenced `jobs` plus `skippedProductIds` — products whose root
+     * already has a PENDING/PROCESSING job. Default auth: service.
+     */
+    recalculate(input: ProductRecalculationInput, auth?: AuthContext): Promise<ProductRecalculationResult>;
+    /** Lists dynamic-variant recalculation jobs, optionally filtered by status. Default auth: anonymous. */
+    listRecalculationJobs(params?: {
+        status?: ProductRecalculationJobStatus;
+    }, auth?: AuthContext): Promise<ProductRecalculationJob[]>;
+    /** Fetches one dynamic-variant recalculation job by id. Default auth: anonymous. */
+    getRecalculationJob(jobId: string, auth?: AuthContext): Promise<ProductRecalculationJob>;
+    /**
+     * Product templates (`/product-templates`). Reads default to anonymous,
+     * writes to service auth.
+     */
+    readonly templates: {
+        /** One page of product templates. Default auth: anonymous. */
+        list: (params?: {
+            pageNumber?: number;
+            pageSize?: number;
+            sort?: string;
+            q?: string;
+        }, auth?: AuthContext) => Promise<ProductTemplate[]>;
+        /** Fetches one product template by id. Default auth: anonymous. */
+        get: (templateId: string, auth?: AuthContext) => Promise<ProductTemplate>;
+        /** Creates a product template. Default auth: service. */
+        create: (input: ProductTemplateCreateInput, auth?: AuthContext) => Promise<ProductTemplateCreated>;
+        /** Full-replaces a product template (`PUT`). Default auth: service. */
+        update: (templateId: string, input: ProductTemplateUpdateInput, auth?: AuthContext) => Promise<void>;
+        /** Deletes a product template. Default auth: service. */
+        delete: (templateId: string, auth?: AuthContext) => Promise<void>;
+    };
 }
 
-export { type Media, type Product, ProductService };
+export { type Media, type Product, type ProductBulkCreateInput, type ProductBulkResult, type ProductBulkUpdateInput, type ProductCreateInput, type ProductCreated, type ProductPatchInput, type ProductRecalculationInput, type ProductRecalculationJob, type ProductRecalculationJobStatus, type ProductRecalculationResult, ProductService, type ProductTemplate, type ProductTemplateCreateInput, type ProductTemplateCreated, type ProductTemplateUpdateInput, type ProductUpdateInput, type ProductWriteOptions };