openapi: 3.0.3
info:
  title: Keeta Menu Management API
  version: v.1.0.0
  contact:
    name: Keeta Developer Website
    email: https://developers.mykeeta.com/
  description: >
    This API provides comprehensive menu management capabilities for Keeta
    platform integration, including menu synchronization, product status
    management, and real-time notifications.
servers:
  - url: https://open.mykeeta.com/api/open
paths:
  /base/image/upload:
    post:
      tags:
        - Product Picture
      operationId: uploadImage
      summary: Image Upload
      description: >
        This endpoint allows merchants to upload images to the Keeta platform.
        The returned image URL can be used during menu synchronization.


        **Rate Limiting:** App-level throttling: **QPS ≤ 50**


        **Implementation Notes:**

        - Different store locations may safely reuse the same image URL, and
        developers should avoid redundant uploads of identical images to prevent
        triggering rate limits.

        - Keeta exclusively accepts JPG and PNG file formats for image
        submissions.

        - Merchants should maintain consistent image dimensions across their
        catalog since significant variations in picture sizes may degrade
        display quality in consumer-facing applications, potentially hindering
        customers' ability to examine product details visually.

        - While the system enforces a hard **maximum file size limit of 5MB**,
        we strongly recommend keeping individual images **under 2MB** to ensure
        optimal performance; uploads exceeding 5MB will automatically fail.

        - Although a 4:3 aspect ratio is recommended for ideal rendering,
        non-compliant images will be automatically cropped by the system, which
        may result in unintended scaling or distortion.

        - Minimum dimension requirements mandate images be at least **600
        pixels** wide and **450 pixels** tall to maintain baseline quality
        standards.

        - Calls must utilize the multipart/form-data content type for parameter
        transmission.

        - Developers must exclude the imgData field from any signature
        calculation processes during authentication.
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required:
                - shopId
                - imageName
                - imageData
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: Unique identifier of the Keeta store.
                  example: 12345
                imageName:
                  type: string
                  description: The name of the image.
                  example: imageName
                imageData:
                  type: string
                  format: binary
                  description: The byte array of the image.
      responses:
        '200':
          description: Successful image upload.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: string
                        description: Photo's URL
                        example: >-
                          https://img-ap-hongkong.mykeeta.net/sailorproduct/9c760595674b395e330cf94b0e5068b09999.jpg
  /product/menu/sync:
    post:
      operationId: menuSync
      tags:
        - OpenItemCode-Based
      summary: Menu Synchronization
      description: >
        This endpoint enables menu synchronization for stores on Keeta. The
        system performs full-menu updates based on the provided data,
        implementing entity matching through the openItemCode field.


        **Rate Limiting**

        App-level throttling: **QPS ≤ 50**


        **Notes**

        1. **Entity Matching Logic**

        The system identifies entities as follows:

        - **Update**: When matching openItemCode values exist in the store's
        current menu

        - **Addition**: When no matching openItemCode values are found

        - **Deletion**: All existing entities with openItemCode values not
        present in the request


        **2. Execution Semantics**

        A successful response only confirms successful submission of the
        synchronization task. Certain items may still fail during processing due
        to validation rules, requiring manual verification and resubmission by
        the caller.


        **3. Image Handling**

        The endpoints supports standard HTTP/HTTPS (ports 80/443) external image
        URLs, which must comply with platform specifications regarding size,
        format, and accessibility.


        **4. Validation Requirements**:


        | **Type** | **Requirements** |

        | --- | --- |

        | **Category** | - The openItemCode field is mandatory and must maintain
        uniqueness across entities<br>- Each store cannot exceed 100 menu
        categories<br>- Category names must be unique within a single store<br>-
        Only one mandatory category is permitted per store<br>- Categories
        become hidden when all contained products are delisted, and are
        repositioned when products become temporarily unavailable |

        | **Choicegroup** | - The openItemCode field is mandatory with
        entity-level uniqueness<br>- Maximum 2,000 option groups per store<br>-
        Maximum 10,000 options per store<br>- Use the relatedSpuOpenItemCode to
        explicitly bind the ChoiceGroupSku to an existing SPU entity<br>- Use
        the relatedSkuOpenItemCode to explicitly bind the ChoiceGroupSku to an
        existing SKU entity. When the ChoiceGroupSku binds to a SKU, it will use
        the bounded SKU''s ChoiceGroups to form a multi-layer ChoiceGroup
        structure.<br>- When both relatedSkuOpenItemCode and
        relatedSpuOpenItemCode are declared, there will be a association check
        to ensure the SKU belongs to the declared SPU.<br>- If both
        relatedSpuOpenItemCode and relatedSkuOpenItemCode are not specified,
        automatic binding occurs when the ChoiceGroupSku name matches a SPU
        name, enabling coordinated SPUs and ChoiceGroupSku status
        management<br><em>(Note: If multiple SPUs share identical names, the
        system randomly selects one for binding, which may lead to unintended
        synchronization.)</em><br>- External image URLs are supported in the
        pictureList field |

        | **Product (SPU)** | - The openItemCode field is mandatory with
        entity-level uniqueness<br>- Maximum 2,000 SPUs per store<br>- Maximum
        15 featured products per store<br>- Tobacco/alcohol products must have
        corresponding attributes marked as "Yes"<br>- External image URLs are
        supported in the pictureList field<br>- Time-limited availability slots
        cannot overlap and are limited to 30 time periods<br>- The
        shopCategoryOpenItemCodeList request should include the menu category
        openItemCode which exists in the specific store<br>- The
        choiceGroupOpenItemCodeList request should include the choicegroup
        openItemCode which exists in the specific store |

        | **Product Sorting** | - Optional field that defaults to upload
        sequence when empty<br>- Requires complete sorting data for all products
        across all categories when provided |
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategoryList
                - choiceGroupList
                - spuList
              example: >-
                {"shopCategoryList":[{"nameTranslation":"開心樂園餐","descriptionTranslation":"開心樂園餐描述","description":"Happy
                Meal
                description","type":0,"descSourceLanguageType":"en","sourceLanguageType":"en","descriptionTranslateType":1,"openItemCode":"SHOP_CATEGORY#10001","availableTime":{"code":0,"values":["string"],"available":[{"endTimestamp":1736956799000,"startTimestamp":1735660800000}]},"targetLanguageType":"zh-HK","descTargetLanguageType":"zh-HK","name":"Happy
                Meal","id":12345,"nameTranslateType":1}],"spuList":[{"nameTranslation":"辣雞腿漢堡","skuList":[{"pickPrice":"28.0","nutritionalInfo":{"property2":0,"property1":0},"specTranslateType":"1","specTranslation":"大份","choiceGroupList":[],"spec":"Large","sourceLanguageType":"en","allergens":["string"],"openItemCode":"SKU#10001","choiceGroupOpenItemCodeList":["GROUP#10001"],"targetLanguageType":"zh-HK","price":"28.0","canteenPrice":"28.0","currency":"HKD","id":12345}],"shopCategoryList":[],"propertyList":[{"propertyName":"","propertyType":1,"customizable":0,"propertyValueList":[{"valueId":9999,"valueName":""}],"maxValueNumber":0,"minValueNumber":0,"propertyId":9999}],"descriptionTranslation":"辣雞腿漢堡描述","description":"Spicy
                Chicken Burger
                description","userGetModeList":["delivery","pickup"],"descSourceLanguageType":"en","isSpecialty":0,"sourceLanguageType":"en","descriptionTranslateType":1,"availableTime":{"code":0,"values":["string"],"available":[{"endTimestamp":1736956799000,"startTimestamp":1735660800000}]},"openItemCode":"SPU#10001","targetLanguageType":"zh-HK","descTargetLanguageType":"zh-HK","name":"Spicy
                Chicken
                Burger","shopCategoryOpenItemCodeList":["SHOP_CATEGORY#10001"],"id":12345,"pictureList":[{"url":"string"}],"nameTranslateType":1,"status":1},{"nameTranslation":"漢堡套餐","skuList":[{"pickPrice":"15.0","nutritionalInfo":{"property2":0,"property1":0},"specTranslateType":"1","specTranslation":"中份","choiceGroupList":[],"spec":"Regular","sourceLanguageType":"en","allergens":["string"],"openItemCode":"SKU#10002","choiceGroupOpenItemCodeList":["GROUP#10002"],"targetLanguageType":"zh-HK","price":"15.0","canteenPrice":"15.0","currency":"HKD","id":12345}],"shopCategoryList":[],"propertyList":[{"propertyName":"","propertyType":1,"customizable":0,"propertyValueList":[{"valueId":9999,"valueName":""}],"maxValueNumber":0,"minValueNumber":0,"propertyId":9999}],"descriptionTranslation":"漢堡套餐","description":"Burger
                Meal
                description","userGetModeList":["delivery","pickup"],"descSourceLanguageType":"en","isSpecialty":0,"sourceLanguageType":"en","descriptionTranslateType":1,"availableTime":{"code":0,"values":["string"],"available":[{"endTimestamp":1736956799000,"startTimestamp":1735660800000}]},"openItemCode":"SPU#10002","targetLanguageType":"zh-HK","descTargetLanguageType":"zh-HK","name":"Burger
                Meal","shopCategoryOpenItemCodeList":["SHOP_CATEGORY#10001"],"id":12345,"pictureList":[{"url":"string"}],"nameTranslateType":1,"status":1}],"spuSequenceCodeMap":{"shopCategoryOpenItemCode2":["spuOpenItemCode1","spuOpenItemCode3"],"shopCategoryOpenItemCode1":["spuOpenItemCode1","spuOpenItemCode2"]},"choiceGroupList":[{"nameTranslation":"選擇醬料","minNumber":0,"openItemCode":"GROUP#10001","targetLanguageType":"zh-HK","maxNumber":3,"repeatable":0,"name":"Sauces","id":0,"choiceGroupSkuList":[{"pickPrice":"12.33","nutritionalInfo":{"property2":0,"property1":0},"nameTranslation":"番茄醬","sourceLanguageType":"en","allergens":["string"],"openItemCode":"CHOICE#10001","targetLanguageType":"zh-HK","price":"12.33","canteenPrice":"12.33","name":"Ketchup","currency":"HKD","id":0,"nameTranslateType":1,"status":1}],"sourceLanguageType":"en","nameTranslateType":1},{"nameTranslation":"選擇漢堡","minNumber":1,"openItemCode":"GROUP#10002","targetLanguageType":"zh-HK","maxNumber":1,"repeatable":0,"name":"Choose
                a
                Burger","id":0,"choiceGroupSkuList":[{"pickPrice":"10.00","nutritionalInfo":{"property2":0,"property1":0},"nameTranslation":"辣雞腿漢堡","relatedSkuOpenItemCode":"SKU#10001","sourceLanguageType":"en","allergens":["string"],"openItemCode":"CHOICE#10002","targetLanguageType":"zh-HK","price":"10.00","canteenPrice":"10.00","name":"Spicy
                Chicken
                Burger","currency":"HKD","id":0,"nameTranslateType":1,"status":1}],"sourceLanguageType":"en","nameTranslateType":1}],"shopId":12345}
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: Unique identifier of the Keeta store.
                  example: 12345
                shopCategoryList:
                  type: array
                  description: >-
                    Please send all the menu category info of the specific store
                    to this field.
                  items:
                    $ref: '#/components/schemas/ShopCategory'
                choiceGroupList:
                  type: array
                  description: >-
                    Please send all the choicegroup info of the specific store
                    to this field.
                  items:
                    $ref: '#/components/schemas/ChoiceGroup'
                spuList:
                  type: array
                  description: >-
                    Please send all the SKU info of the specific store to this
                    field.
                  items:
                    $ref: '#/components/schemas/SPU'
                spuSequenceCodeMap:
                  type: object
                  description: >
                    This field allows developers to set product sorting within
                    menu categories. When the value equals null, product sorting
                    follows Keeta's default sorting.


                    **Data Structure**: 

                    - **Key**: Menu category's OpenItemCode

                    - **Value**: Array of SPU OpenItemCodes in desired display
                    order


                    Merchants can specify exact product order by listing SPU
                    OpenItemCodes in the desired sequence for each category. The
                    specified order updates the in-app display, showcasing
                    products in the defined arrangement.
                  additionalProperties:
                    type: array
                    description: Ordered list of SPU OpenItemCodes for this category
                    items:
                      type: string
                      description: SPU OpenItemCode
                  example:
                    shopCategoryOpenItemCode1:
                      - spuOpenItemCode1
                      - spuOpenItemCode2
                    shopCategoryOpenItemCode2:
                      - spuOpenItemCode1
                      - spuOpenItemCode3
      responses:
        '200':
          description: Request executed successfully
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: integer
                        format: int64
                        description: >
                          When interacting with Keeta's platform for actions
                          that require asynchronous processing, such as complex
                          data operations or system integrations, the platform
                          will initiate a task that may not complete immediately
                          upon request submission. Instead of providing
                          immediate completion confirmation, Keeta's system
                          generates a taskId, which serves as a unique
                          identifier for that specific task in the internal
                          execution system.
  /product/spustatus/batchupdatebycode:
    post:
      operationId: batchUpdateSPUStatus
      tags:
        - OpenItemCode-Based
      summary: Batch Update SPU Status
      description: >
        This endpoint allows the bulk updating of product statuses using their
        SPU OpenItemCode.


        **Rate Limiting**

        App-level throttling: **QPS ≤ 10**


        **Notes**

        - The openItemCode field is mandatory with SPU entity-level uniqueness.


        - This endpoint supports partial successful updates when processing
        multiple SPUs in a single request. However, if the entire request
        contains fundamental structural errors the system will reject the
        complete batch with a fail response.


        - When the needLinkage parameter is set to 1, this endpoint facilitates
        the comprehensive synchronization of status changes not only for the
        specified SPUs but also for all associated ChoiceGroupSkus. This
        advanced functionality ensures cohesive inventory and product display
        management across related product options.


        - Each request cannot exceed 200 SPUs.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuOpenItemCodeList
                - status
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: Unique identifier of the Keeta store.
                  example: 12345
                spuOpenItemCodeList:
                  type: array
                  description: A list of SPU OpenItemCode
                  items:
                    type: string
                  example:
                    - aCV
                    - 2code
                status:
                  type: integer
                  description: >-
                    This field controls the visibility and availability of a SPU
                    in the merchant storefront. Status = 0, this setting will
                    immediately deactivate the specified SPU. Status = 1, this
                    setting activates the SPU for public visibility and
                    ordering.
                  example: 1
                needLinkage:
                  type: integer
                  description: >-
                    This field determines whether the status change should
                    propagate to related SKUs, with these behaviors: When
                    needLinkage equals 0 the status update applies exclusively
                    to the specified ChoiceGroupSku without affecting any
                    related products. When needLinkage equals 1, the system will
                    automatically identify and update all logically connected
                    ChoiceGroupSkus based on existing mapping between
                    ChoiceGroupSku names match SPU names
                  example: 1
      responses:
        '200':
          description: Request executed successfully
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: >-
                          Contains a list of OpenItemCodes for all SPUs whose
                          statuses were successfully changed.
                        items:
                          type: string
                      errorList:
                        type: array
                        description: >-
                          Failed SPUs list includes OpenItemCode and Error
                          Message.
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/choicegroupskustatus/batchupdatebycode:
    post:
      operationId: batchUpdateChoiceGroupSkuStatus
      tags:
        - OpenItemCode-Based
      summary: Batch Update ChoiceGroupSku Status
      description: >
        This endpoint allows users to efficiently modify the status of
        ChoicegroupSkus using their OpenItemCode.


        **Rate Limiting**

        App-level throttling: **QPS ≤ 10**


        **Notes**

        - When developers call this endpoint to update the status of multiple
        options on the Keeta platform, it's essential to understand that the API
        processes each option independently. This can result in partial success,
        where some options are successfully updated while others encounter
        errors.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - choiceGroupSkuCodePackList
                - status
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: Unique identifier of the Keeta store.
                  example: 12345
                choiceGroupSkuCodePackList:
                  type: array
                  description: >-
                    This field includes ChoicegroupSkus that required status
                    updates.
                  items:
                    $ref: '#/components/schemas/ChoiceGroupSkuCodePack'
                status:
                  type: integer
                  description: >-
                    This field controls the visibility and availability of a
                    ChoiceGroupSku in the merchant storefront.

                    Status = 0, this setting will immediately deactivate the
                    specified ChoiceGroupSku.

                    Status = 1, this setting activates the ChoiceGroupSku for
                    public visibility and ordering.
                  example: 1
      responses:
        '200':
          description: Request executed successfully
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: integer
                        format: int64
                        example: 239
                        description: >-
                          The quality of OpenItemCodes of choicegroupsku whose
                          statuses were successfully changed.
                      errorList:
                        type: array
                        description: >-
                          A list contains the OpenItemCode for each option whose
                          status update failed.
                        items:
                          $ref: '#/components/schemas/ErrorChoiceGroup'
  /product/mapping/batchupdatebyname:
    post:
      operationId: batchBindOpenItemCode
      tags:
        - OpenItemCode-Based
      summary: Batch Bind OpenItemCode
      description: >
        The endpoints allows developers setting the OpenItemCode mapping
        relationship using store ID and product name.


        **Rate Limiting**

        App-level throttling: **QPS ≤ 10**


        **Notes**

        - Existing partners that have already integrated via Keeta ID-based APIs
        must complete OpenItemCode binding for their existing products through
        this API before switching to OpenItemCode-based APIs, if they have
        previously created marketing campaigns on the Keeta platform.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuMappingList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: Unique identifier of the Keeta store
                  example: 12345
                spuMappingList:
                  type: array
                  description: >-
                    Please specify the mapping relationship between SPU names
                    and their corresponding openItemCodes in this field. For
                    detailed definitions of openItemCode, please refer to the
                    []()Menu Development Guide documentation.
                  items:
                    $ref: '#/components/schemas/SpuMapping'
      responses:
        '200':
          description: Request executed successfully
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: >-
                          Returns a list of OpenItemCode values for all SPUs
                          that were successfully bound during this API request.
                        items:
                          type: string
                      errorList:
                        type: array
                        description: >-
                          Returns detailed information about SPUs that failed to
                          bind, including SPU OpenItemCode and error message.
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/shopcategory/list:
    post:
      operationId: queryShopCategoryList
      tags:
        - KeetaID-Based
      summary: Query ShopCategory list
      description: |
        Query the list of ShopCategory information in store.

        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
      responses:
        '200':
          description: Successful returns ShopCategory list.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: In-store ShopCategory list
                        items:
                          $ref: '#/components/schemas/ShopCategory'
  /product/shopcategory/create:
    post:
      operationId: createShopCategory
      tags:
        - KeetaID-Based
      summary: Create a ShopCategory
      description: >
        - Only for creating in-store ShopCategory.

        - The names of ShopCategory in a store are not allowed to be repeated.

        - The maximum "mandatory" ShopCategory number for each store is 1.

        - When there is no product available for sale under the ShopCategory
        (including products offshelf), the ShopCategory will not be displayed on
        our user APP.

        - The number of ShopCategory can not exceed 100.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategory
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                shopCategory:
                  $ref: '#/components/schemas/ShopCategory'
      responses:
        '200':
          description: Successful creation.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        $ref: '#/components/schemas/ShopCategory'
  /product/shopcategory/update:
    post:
      operationId: updateShopCategory
      tags:
        - KeetaID-Based
      summary: Modify a ShopCategory
      description: |
        - To update a ShopCategory information, will keep its original ID
        - Please ensure that each parameter is the value you want to update.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategory
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                shopCategory:
                  $ref: '#/components/schemas/ShopCategory'
      responses:
        '200':
          description: Successful update.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        $ref: '#/components/schemas/ShopCategory'
  /product/shopcategory/batchdel:
    post:
      operationId: deleteShopCategories
      tags:
        - KeetaID-Based
      summary: Delete ShopCategories(in batch)
      description: |
        1. You can only delete ShopCategory that doesn't contain any product.
        2. Please make sure the ShopCategory.id is in-store.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategoryIdList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                shopCategoryIdList:
                  type: array
                  description: ShopCategory id list to be deleted
                  items:
                    type: integer
                    format: int64
                  example:
                    - 2313
                    - 4342
      responses:
        '200':
          description: Batch deletion result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: successful ShopCategory id list
                        items:
                          type: integer
                          format: int64
                      errorList:
                        type: array
                        description: failed ShopCategory data
                        items:
                          $ref: '#/components/schemas/ErrorShopCategory'
  /product/shopcategory/updatesequence:
    post:
      operationId: updateShopCategorySequence
      tags:
        - KeetaID-Based
      summary: Adjust order of a ShopCategory
      description: >
        - Adjust one specific ShopCategory's order, the sequence need to be
        greater than 0 and less than the number of ShopCategories.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - id
                - shopId
                - sequence
              properties:
                id:
                  type: integer
                  format: int64
                  description: ShopCategory id
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                sequence:
                  type: integer
                  example: 2455425486
                  description: target sequence
      responses:
        '200':
          $ref: '#/components/responses/Success'
  /product/shopcategory/batchupdatesequence:
    post:
      operationId: batchUpdateShopCategorySequence
      tags:
        - KeetaID-Based
      summary: Adjust order of ShopCategories(in batch)
      description: >
        - Adjust all ShopCategories' sequence in store.

        - Please make sure openShopCategorySequenceDTOList contains all
        shopCategory in store, otherwise the interface invoke will be rejected.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - openShopCategorySequenceDTOList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                openShopCategorySequenceDTOList:
                  type: array
                  description: ShopCategory target sequence data model
                  items:
                    $ref: '#/components/schemas/OpenShopCategorySequenceDTO'
      responses:
        '200':
          $ref: '#/components/responses/Success'
  /product/categoryproperty/list:
    post:
      operationId: queryCategoryPropertyList
      tags:
        - KeetaID-Based
      summary: Query category attribute list
      description: >
        1. Get the category attribute list based on the final category ID, which
        is used for operations such as creating products.

        2. Since there is no backend category field for this period, the
        categoryId can be fixed to -1.


        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                categoryId:
                  type: integer
                  format: int64
                  description: KeeTa platform categoryId
                  example: -1
      responses:
        '200':
          description: Successful returns category attribute list.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: attributes related to the category
                        items:
                          $ref: '#/components/schemas/CategoryProperty'
  /product/spu/list:
    post:
      operationId: queryProductsList
      tags:
        - KeetaID-Based
      summary: Query products list
      description: |
        1. Get all valid products in store.

        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
      responses:
        '200':
          description: Successful returns product list.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Spu data model
                        items:
                          $ref: '#/components/schemas/SPU'
  /product/spu/detail:
    post:
      operationId: queryProductDetail
      tags:
        - KeetaID-Based
      summary: Query a specific product
      description: >
        1. Get a specific product info through ID, this is far more fast
        comparing to query products list.


        **Rate limit:** 100 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuId
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuId:
                  type: integer
                  format: int64
                  description: spuId in KeeTa
                  example: 2
      responses:
        '200':
          description: Successful returns product detail.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        $ref: '#/components/schemas/SPU'
  /product/spu/batchcreate:
    post:
      operationId: createProducts
      tags:
        - KeetaID-Based
      summary: Create products(in batch)
      description: >
        1. Product data that can be transmitted in one batch should not exceed
        200. If there are more products, please create them in batches.

        2. The interface supports partial synchronization success and partial
        synchronization failure. However, if there is a parameter format error,
        all will fail.

        3. You can not create "ShopCategory" or "ChoiceGroup" through this
        interface, please make sure all the ShopCategory.id and ChoiceGroup.id
        are already exist in store.

        4. Regarding the product image related Field, please use the "Image
        upload API" to upload the image to the KeeTa system first, than get the
        image URL and pass into the Picture.url field.

        5. If it is a tobacco and alcohol product, please be sure to fill in the
        relevant attributes in the [Product Attributes] field to avoid
        regulatory issues.

        6. If a Spu contains only one Sku, then the Sku.spec field is allowed to
        remain empty, otherwise the Sku.spec in a specific Spu need to be
        filled.

        7. The Sku.price is required and supports up to two decimal places.

        8. Spu.avaliableTime is required.

        9. "Specialty" dish can not exceed 15 in a store.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuList:
                  type: array
                  description: Spu data model
                  items:
                    $ref: '#/components/schemas/SPU'
      responses:
        '200':
          description: Batch creation result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: successful Spu data model
                        items:
                          $ref: '#/components/schemas/SPU'
                      errorList:
                        type: array
                        description: failed Spu informations
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/spu/batchupdate:
    post:
      operationId: updateProducts
      tags:
        - KeetaID-Based
      summary: Modify products(in batch)
      description: >
        1. Mostly like 3.3.3.

        2. Through this interface, you can update Spu with its ID unchanged,
        **this is very important for Promotion activities, which are based on
        Spu.id and Sku.id**.

        3. As for Sku, if the Sku.id is filled, please make sure the Sku.id is
        belongs to this Spu. If Sku.id is not filled, we will treat it as a new
        one.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuList:
                  type: array
                  description: Spu data model
                  items:
                    $ref: '#/components/schemas/SPU'
      responses:
        '200':
          description: Batch update result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful Spu data model
                        items:
                          $ref: '#/components/schemas/SPU'
                      errorList:
                        type: array
                        description: failed Spu informations
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/spustatus/batchupdate:
    post:
      operationId: updateProductsStatus
      tags:
        - KeetaID-Based
      summary: Modify the available and unavailable status(in batch)
      description: >
        1. Product data that can be transmitted in one batch should not exceed
        200. If there are more products, please create them in batches.

        2. The interface supports partial synchronization success and partial
        synchronization failure. However, if there is a parameter format error,
        all will fail.

        3. If there is no available product in a ShopCategory, the ShopCategory
        will disapear at user APP.

        4. If needLinkage=1, this API will also modify the status linked to the
        ChoiceGroupSkus (the same name with Spu). But if the ChoiceGroupSku
        status violates the rule of ChoiceGroup, it wouldn't be modified.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuIdList
                - status
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuIdList:
                  type: array
                  description: Spu id list
                  items:
                    type: integer
                    format: int64
                  example:
                    - 1
                    - 2
                    - 3
                status:
                  type: integer
                  description: 1 - available 0 - unavailable
                  example: 1
                needLinkage:
                  type: integer
                  description: 1 - need linkage modification else - no need
                  example: 1
                  default: 0
      responses:
        '200':
          description: Batch status update result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful Spu data model
                        items:
                          $ref: '#/components/schemas/SPU'
                      errorList:
                        type: array
                        description: Failed Spu informations
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/spu/batchcheck:
    post:
      operationId: checkProductsConflict
      tags:
        - KeetaID-Based
      summary: Query conflict ChoiceGroup before unavailable (in batch)
      description: >
        1. Query if there is any rule-violated ChoiceGroup when unavailable a
        Spu with linkage.


        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuIdList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuIdList:
                  type: array
                  description: spuId list
                  items:
                    type: integer
                    format: int64
                  example:
                    - 1
                    - 2
                    - 3
      responses:
        '200':
          description: Conflict check result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: conflict group data model
                        items:
                          $ref: '#/components/schemas/ConflictGroup'
                      errorList:
                        type: array
                        description: failed Spu information
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/spu/batchdel:
    post:
      operationId: deleteProducts
      tags:
        - KeetaID-Based
      summary: Delete products(in batch)
      description: >
        1. Product data that can be transmitted in one batch should not exceed
        200. If there are more products, please delete them in batches.

        2. The interface supports partial synchronization success and partial
        synchronization failure. However, if there is a parameter format error,
        all will fail.

        3. If needLinkage=1, this API will also delete the linked
        ChoiceGroupSkus (the same name with Spu). But if the ChoiceGroupSku
        status violates the rule of ChoiceGroup, it wouldn't be modified.


        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuIdList
                - linkedDel
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                spuIdList:
                  type: array
                  description: spuId list
                  items:
                    type: integer
                    format: int64
                  example:
                    - 1
                    - 2
                    - 3
                linkedDel:
                  type: boolean
                  description: 'true: need linkage deletion false:no need'
                  example: true
      responses:
        '200':
          description: Batch deletion result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: successful spuId list
                        items:
                          type: integer
                          format: int64
                      errorList:
                        type: array
                        description: failed Spu informations
                        items:
                          $ref: '#/components/schemas/ErrorSpu'
  /product/spu/updatesequence:
    post:
      operationId: updateProductSequence
      tags:
        - KeetaID-Based
      summary: Adjust order of a product(in a specific ShopCategory)
      description: |
        1. Adjust a product's sequence in a specific ShopCategory.
        2. 0 < sequence <= number of spus.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategoryId
                - spuId
                - sequence
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 1
                shopCategoryId:
                  type: integer
                  format: int64
                  description: ShopCategory.id
                  example: 22
                spuId:
                  type: integer
                  format: int64
                  description: spuId
                  example: 333
                sequence:
                  type: integer
                  description: target sequence
                  example: 2
      responses:
        '200':
          $ref: '#/components/responses/Success'
  /product/spu/batchupdatesequence:
    post:
      operationId: batchUpdateProductSequence
      tags:
        - KeetaID-Based
      summary: Adjust products order in a ShopCategory(in batch)
      description: >
        1. Adjust all products' sequence in a specific ShopCategory.

        2. 0 < sequence <= number of spus.

        3. Please make sure spuSequenceDTOList contains all Spu in the
        ShopCategory, otherwise it will fail.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategoryId
                - spuSequenceDTOList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                shopCategoryId:
                  type: integer
                  format: int64
                  description: ShopCategory id
                spuSequenceDTOList:
                  type: array
                  description: Spu sequence data model
                  items:
                    $ref: '#/components/schemas/OpenSpuSequenceDTO'
      responses:
        '200':
          $ref: '#/components/responses/Success'
  /product/spu/batchupdateallsequence:
    post:
      operationId: batchUpdateAllProductSequence
      tags:
        - KeetaID-Based
      summary: Adjust products order in a Shop(in batch)
      description: |
        1. Mostly like 3.3.9 but support multiple ShopCategories.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - shopCategoryId2SpuSeqMap
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                shopCategoryId2SpuSeqMap:
                  type: object
                  description: 'key: ShopCategory.id value: Spu sequence data model'
                  additionalProperties:
                    type: array
                    items:
                      $ref: '#/components/schemas/OpenSpuSequenceDTO'
      responses:
        '200':
          description: Batch update all sequence result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful ShopCategory id
                        items:
                          type: integer
                          format: int64
                      errorList:
                        type: array
                        description: failed ShopCategory informations
                        items:
                          $ref: '#/components/schemas/ErrorShopCategory'
  /product/spupicture/batchbind:
    post:
      operationId: batchBindProductPictures
      tags:
        - KeetaID-Based
      summary: Batch bind Spus picture(support other image urls)
      description: >
        1. Noticed this is an Asynchronous API, if you want to subscribe error
        messages, please configure webhook with 「eventId=1201」;

        2. Make sure all spuIds are belong to shopId;

        3. Image requirements:
           1. Image url can be access directly. We only support HTTP/HTTPS protocol for default port (80/tcp or 443/tcp), please don't use other ports;
           2. Image size cannot exceed 5M, the minimum aspect of image is 600px * 450px;
           3. In image url's header field, the Content-Type can only be "**image/jpeg**" or "**image/png**";

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - spuPictureList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 123
                spuPictureList:
                  type: array
                  items:
                    $ref: '#/components/schemas/SpuPicture'
      responses:
        '200':
          description: Batch bind pictures task submitted.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: integer
                        format: int64
                        description: taskId of this invocation
  /product/choicegroup/list:
    post:
      operationId: queryChoiceGroupList
      tags:
        - KeetaID-Based
      summary: Query ChoiceGroup list
      description: |
        1. Query all ChoiceGroups in store.

        **Rate limit:** 50 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
      responses:
        '200':
          description: Successful returns ChoiceGroup list.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: ChoiceGroup data model
                        items:
                          $ref: '#/components/schemas/ChoiceGroup'
  /product/choicegroup/batchcreate:
    post:
      operationId: createChoiceGroups
      tags:
        - KeetaID-Based
      summary: Create ChoiceGroups(in batch)
      description: >
        1. if the ChoiceGroupSku.name is the same as Spu.name, normally they
        will bound.

        2. ChoiceGroup.maxNumber should greater than or equals to
        ChoiceGroup.minNumber and ChoiceGroup.maxNumber should greater than 0.

        3. ChoiceGroupSku.price is required, status is required.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - choiceGroupList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                choiceGroupList:
                  type: array
                  description: ChoiceGroup data model
                  items:
                    $ref: '#/components/schemas/ChoiceGroup'
      responses:
        '200':
          description: Batch creation result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful ChoiceGroup data model
                        items:
                          $ref: '#/components/schemas/ChoiceGroup'
                      errorList:
                        type: array
                        description: Failed ChoiceGroup informations
                        items:
                          $ref: '#/components/schemas/ErrorChoiceGroup'
  /product/choicegroup/batchupdate:
    post:
      operationId: updateChoiceGroups
      tags:
        - KeetaID-Based
      summary: Modify ChoiceGroups(in batch)
      description: |
        1. Mostly like 3.4.2 but ChoiceGroup.id is required.
        2. Please make sure the ChoiceGroup data object is complete.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - choiceGroupList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                choiceGroupList:
                  type: array
                  description: ChoiceGroup data model
                  items:
                    $ref: '#/components/schemas/ChoiceGroup'
      responses:
        '200':
          description: Batch update result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful ChoiceGroup data model
                        items:
                          $ref: '#/components/schemas/ChoiceGroup'
                      errorList:
                        type: array
                        description: Failed ChoiceGroup informations
                        items:
                          $ref: '#/components/schemas/ErrorChoiceGroup'
  /product/choicegroup/listappliedspu:
    post:
      operationId: queryChoiceGroupAppliedSpu
      tags:
        - KeetaID-Based
      summary: Batch query which products are using these ChoiceGroups
      description: |
        1. Query ChoiceGroup's applied products.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - choiceGroupIdList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                choiceGroupIdList:
                  type: array
                  description: ChoiceGroup id list
                  items:
                    type: integer
                    format: int64
                  example:
                    - 3123
                    - 4343
      responses:
        '200':
          description: Query applied SPU result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful ChoiceGroupAppliedSpu data model
                        items:
                          $ref: '#/components/schemas/ChoiceGroupAppliedSpu'
                      errorList:
                        type: array
                        description: >-
                          Failed choiceGroup informations, mostly the wrong
                          ChoiceGroup.id
                        items:
                          $ref: '#/components/schemas/ErrorChoiceGroup'
  /product/choicegroup/batchdel:
    post:
      operationId: deleteChoiceGroups
      tags:
        - KeetaID-Based
      summary: Delete ChoiceGroups(in batch)
      description: |
        1. Batch delete ChoiceGroups and related ChoiceGroupSkus.

        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - choiceGroupIdList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                  example: 25381
                choiceGroupIdList:
                  type: array
                  description: ChoiceGroup id list
                  items:
                    type: integer
                    format: int64
                  example:
                    - 3123
                    - 4343
      responses:
        '200':
          description: Batch deletion result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        description: Successful ChoiceGroup id list
                        items:
                          type: integer
                          format: int64
                      errorList:
                        type: array
                        description: Failed ChoiceGroup informations
                        items:
                          $ref: '#/components/schemas/ErrorChoiceGroup'
  /product/choicegroupskustatus/batchupdate:
    post:
      operationId: updateChoiceGroupSkuStatus
      tags:
        - KeetaID-Based
      summary: Modify ChoiceGroupSkus available/unavailable status(in batch)
      description: >
        1. Notice that the available ChoiceGroupSkus should greater than or
        equals to minNumber.


        **Rate limit:** 10 QPS by appId dimension.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - shopId
                - status
                - choiceGroupSkuIdPackList
              properties:
                shopId:
                  type: integer
                  format: int64
                  description: store id in KeeTa
                status:
                  type: integer
                  description: 0 - unavailable 1 - available
                choiceGroupSkuIdPackList:
                  type: array
                  description: >-
                    Please make sure choiceGroupSkuIds are all belongs to
                    choiceGroupId
                  items:
                    $ref: '#/components/schemas/ChoiceGroupSkuIdPack'
      responses:
        '200':
          description: Batch status update result.
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/CommonResponse'
                  - type: object
                    properties:
                      data:
                        type: integer
                        format: int64
                        description: Successful count
x-webhooks:
  menuSynchronizationTaskCompletionWebhook:
    post:
      operationId: menuSynchronizationTaskCompletionNotification
      tags:
        - Webhooks
      summary: Menu Synchronization Task Completion Notification
      description: >
        The **Menu Synchronization** API operates asynchronously. When Keeta's
        platform receives a synchronization request, it creates an internal task
        for processing. Upon task completion (success or failure), Keeta will
        notify developers via this webhook.


        **Event ID:** 1202
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                shopId:
                  type: integer
                  format: int64
                  example: 25381
                  description: Unique identifier of the Keeta store.
                taskId:
                  type: integer
                  format: int64
                  example: 897354
                  description: >-
                    Due to this being an asynchronous task, when Keeta platform
                    receives the request, it cannot complete the task
                    immediately. Keeta platform will submit a task to run in the
                    internal system, and this field represents the unique ID of
                    that task.
                errorSpuDTOList:
                  type: array
                  description: >-
                    This field represents detailed information about the product
                    list that failed menu synchronization.
                  items:
                    type: object
                    properties:
                      id:
                        type: integer
                        example: 123
                      name:
                        type: string
                        example: banana tea
                      code:
                        type: integer
                        example: 199999
                      message:
                        type: string
                        example: error message info
                      openItemCode:
                        type: string
                        example: y123456
      responses:
        '200':
          $ref: '#/components/responses/Success'
components:
  responses:
    Success:
      description: Request executed successfully
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/CommonResponse'
  schemas:
    CommonResponse:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: integer
          description: >
            A numeric status identifier indicating the result of the interface
            call, used to determine whether the operation executed
            successfully. 
          x-enumDescriptions:
            '0': The request was executed successfully.
            Non-zero value: >-
              The request execution failed. Specific error details can be viewed
              in the message field.
          example: 0
        message:
          type: string
          description: >-
            Text description corresponding to the status code, explaining the
            operation result or error cause to users.
          example: Success
    ShopCategory:
      type: object
      required:
        - name
        - sourceLanguageType
        - type
        - openItemCode
      properties:
        id:
          type: integer
          format: int64
          example: 12345
          description: >-
            Keeta's menu category ID. Not required for OpenItemCode-based APIs.
            Required for updates in Keeta ID-based APIs.
        name:
          type: string
          example: Happy Meal
          description: Name of the category in a menu
        sourceLanguageType:
          type: string
          example: en
          description: >-
            Language type of the name field. Supported language enums can be
            found in Menu Integration Guide
        nameTranslation:
          type: string
          example: 開心樂園餐
          description: Translated text for the name field
        targetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language type of nameTranslation. Required when nameTranslation is
            provided.
        nameTranslateType:
          type: integer
          example: 1
          description: >-
            Source of name translation. When the value equals 1, it indicates
            that the name translation was provided by the merchant.
        type:
          type: integer
          example: 0
          description: |
            Indicates the menu category type: 
          x-enumDescriptions:
            '0': indicates a regular optional category (customers may skip)
            '1': >-
              indicates a required category (customers must select at least one
              item)
        description:
          type: string
          example: Happy Meal description
          description: Brief description of the category in a menu
        descSourceLanguageType:
          type: string
          example: en
          description: Language type of description. Required if description exists.
        descriptionTranslation:
          type: string
          example: 開心樂園餐描述
          description: Translated text for description
        descTargetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language type of descriptionTranslation. Required when
            descriptionTranslation exists.
        descriptionTranslateType:
          type: integer
          example: 1
          description: >-
            Source of description translation. When the value equals 1, it
            indicates that the description translation was provided by the
            merchant.
        openItemCode:
          type: string
          example: SHOP_CATEGORY#10001
          description: >-
            Third-party category ID. Mandatory and must be unique in
            OpenItemCode-based APIs. Optional in Keeta ID-based APIs.
        availableTime:
          allOf:
            - description: >-
                Selling time slots for this category. Categories are unavailable
                outside these times.
            - $ref: '#/components/schemas/AvailableTime'
    SPU:
      type: object
      required:
        - name
        - sourceLanguageType
        - status
        - skuList
        - availableTime
        - isSpecialty
        - openItemCode
        - shopCategoryOpenItemCodeList
        - userGetModeList
      properties:
        id:
          type: integer
          format: int64
          example: 12345
          description: >-
            Unique SPU ID generated by Keeta. Not required in OpenItemCode-based
            APIs. Required for updates in Keeta ID-based APIs. See "Menu
            Development Guide" for details.
        name:
          type: string
          example: Spicy Chicken Burger
          description: Product name
        sourceLanguageType:
          type: string
          example: en
          description: Language code for name field (refer to Menu Integration Guide)
        nameTranslation:
          type: string
          example: 辣雞腿漢堡
          description: Localized name translation
        targetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language code for nameTranslation (required if translation exists),
            please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        nameTranslateType:
          type: integer
          example: 1
          description: >-
            Source of name translation. When the value equals 1, it indicates
            that the name translation was provided by the merchant.
        status:
          type: integer
          example: 1
          description: |
            Product availability status: 
          x-enumDescriptions:
            '0': indicates the SPU is unavailable
            '1': indicates the SPU is available
        description:
          type: string
          example: Spicy Chicken Burger description
          description: Product description
        descSourceLanguageType:
          type: string
          example: en
          description: >-
            Language code for description (required if description exists),
            please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        descriptionTranslation:
          type: string
          example: 辣雞腿漢堡描述
          description: Localized description translation
        descTargetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language code for descriptionTranslation (required if translation
            exists), please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        descriptionTranslateType:
          type: integer
          example: 1
          description: >-
            Source of description translation. When the value equals 1, it
            indicates that the description translation was provided by the
            merchant.
        shopCategoryList:
          type: array
          description: >-
            Menu categories this SPU belongs to. The 'id' field is required when
            not using menuSync API. For all interfaces using this struct except
            menuSync, the id field in ShopCategory struct is required to
            associate SPUs with category.
          items:
            $ref: '#/components/schemas/ShopCategory'
        pictureList:
          type: array
          description: Product image URLs
          items:
            $ref: '#/components/schemas/Picture'
        propertyList:
          type: array
          description: SPU specifications (e.g., "Size" options for pizza)
          items:
            $ref: '#/components/schemas/CategoryProperty'
        skuList:
          type: array
          description: A list includes all SKUs under this SPU
          items:
            $ref: '#/components/schemas/SKU'
        availableTime:
          allOf:
            - description: Selling time slots for this product
            - $ref: '#/components/schemas/AvailableTime'
        isSpecialty:
          type: integer
          example: 0
          description: |
            Signature dish indicator: 
          x-enumDescriptions:
            '0': indicates a regular item
            '1': indicates a signature dish
        openItemCode:
          type: string
          example: SPU#10001
          description: >-
            Developer-provided SPU identifier. Mandatory and unique in
            OpenItemCode-based APIs.
        shopCategoryOpenItemCodeList:
          type: array
          description: >-
            This field contains the OpenItemCodes that correspond to menu
            categories in Keeta's system. When calling the menu synchronization
            (menuSync) API, this field becomes mandatory. The OpenItemCodes are
            provided by developers and maintain a one-to-one relationship with
            Keeta's internal menu category IDs. The Keeta platform will verify
            whether these OpenItemCodes actually exist in the merchant's store.
          items:
            type: string
          example:
            - 2$33419
            - 3$34747
        userGetModeList:
          type: array
          description: >-
            This field specifies the supported order fulfillment modes, with
            case-sensitive values. By default, all products support "delivery"
            mode. To enable "pickup" mode, the following conditions must be
            satisfied: First, every SKU in the skuList must have a valid
            pickPrice value specified. Second, all options within every choice
            group associated with these SKUs must also have pickPrice values
            defined. The system recognizes two mode values: "delivery" for
            standard food delivery services "pickup" for customer
            self-collection scenarios
          items:
            type: string
          example:
            - delivery
            - pickup
    SKU:
      type: object
      required:
        - openItemCode
      properties:
        id:
          type: integer
          format: int64
          example: 12345
          description: >-
            Unique SKU ID generated by Keeta system. Not required in
            OpenItemCode-based APIs. Required for updates in Keeta ID-based
            APIs. For details, see "Menu Development Guide" for details.
        spec:
          type: string
          example: Large
          description: Specification name (optional for single-spec products)
        sourceLanguageType:
          type: string
          example: en
          description: Language code for name field (refer to Menu Integration Guide)
        specTranslation:
          type: string
          example: 大份
          description: Localized specification translation
        targetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language code for specTranslation (required if translation exists),
            please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        specTranslateType:
          type: string
          example: '1'
          description: >-
            Source of spec translation. When the value equals 1, it indicates
            that the spec translation was provided by the merchant.
        price:
          type: string
          example: '28.0'
          description: Delivery price (supports 3 decimal places, e.g. "12.33")
        pickPrice:
          type: string
          example: '28.0'
          description: Pickup price (supports 3 decimal places)
        canteenPrice:
          type: string
          example: '28.0'
          description: Dine-in price (supports 3 decimal places)
        currency:
          type: string
          example: HKD
          description: >-
            Currency code (refer to "Currency Symbols" enum). Defaults to
            merchant's currency if empty.
        choiceGroupList:
          type: array
          description: >-
            List of ChoiceGroups associated with this SKU. Not used for menuSync
            API.
          items:
            $ref: '#/components/schemas/ChoiceGroup'
        openItemCode:
          type: string
          example: SKU#10001
          description: >-
            Developer-provided SKU identifier. Mandatory and unique in
            OpenItemCode-based APIs. Optional for Keeta-based ID APIs.
        choiceGroupOpenItemCodeList:
          type: array
          description: OpenItemCodes of associated ChoiceGroups. Required for menuSync API.
          items:
            type: string
        nutritionalInfo:
          type: object
          description: Nutritional components (refer to "Nutritional Elements" enum)
          additionalProperties:
            type: integer
        allergens:
          type: array
          description: Allergen information (refer to "Allergens" enum)
          items:
            type: string
    ChoiceGroup:
      type: object
      required:
        - name
        - sourceLanguageType
        - minNumber
        - maxNumber
        - choiceGroupSkuList
        - openItemCode
      properties:
        id:
          type: integer
          format: int64
          example: 0
          description: >-
            Unique ChoiceGroup ID generated by Keeta system. Not required in
            OpenItemCode-based APIs. Required for updates in Keeta ID-based
            APIs.
        name:
          type: string
          example: Sauces
          description: Display name of the ChoiceGroup
        sourceLanguageType:
          type: string
          example: en
          description: Language code for name field (refer to Menu Integration Guide)
        nameTranslation:
          type: string
          example: 選擇醬料
          description: Localized name translation
        targetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language code for nameTranslation (required if translation exists),
            please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        nameTranslateType:
          type: integer
          example: 1
          description: >-
            Source of name translation. When the value equals 1, it indicates
            that the name translation was provided by the merchant.
        minNumber:
          type: integer
          example: 0
          description: Minimum number of ChoiceGroupSkus that must be selected
        maxNumber:
          type: integer
          example: 3
          description: Maximum number of ChoiceGroupSkus that can be selected
        choiceGroupSkuList:
          type: array
          description: List of available ChoiceGroupSkus in this ChoiceGroup
          items:
            $ref: '#/components/schemas/ChoiceGroupSku'
        openItemCode:
          type: string
          example: GROUP#10001
          description: >-
            Developer-provided ChoiceGroup identifier. Mandatory and unique in
            OpenItemCode-based APIs.
        repeatable:
          type: integer
          example: 0
          description: |
            Multiple selection flag: 
          x-enumDescriptions:
            '0': indicates single selection only
            '1': allows multiple selections of the same ChoiceGroupSku
    ChoiceGroupSku:
      type: object
      required:
        - name
        - sourceLanguageType
        - status
        - openItemCode
      properties:
        id:
          type: integer
          format: int64
          example: 0
          description: >-
            Primary key for ChoiceGroupSku, mainly used for order API alignment.
            Changes when names are modified. Not required in OpenItemCode-based
            APIs. Required for updates in Keeta ID-based APIs.
        name:
          type: string
          example: Ketchup
          description: >-
            Display name of the ChoiceGroupSku. Should match SPU name when
            representing the same product for internal correlation.
        sourceLanguageType:
          type: string
          example: en
          description: Language code for name field (refer to Menu Integration Guide)
        nameTranslation:
          type: string
          example: 番茄醬
          description: Localized name translation
        targetLanguageType:
          type: string
          example: zh-HK
          description: >-
            Language code for nameTranslation (required if translation exists),
            please refer to [Menu API Integration
            Guide](./docs/menuIntegrationGuide.md)
        nameTranslateType:
          type: integer
          example: 1
          description: >-
            Source of name translation. When the value equals 1, it indicates
            that the name translation was provided by the merchant.
        price:
          type: string
          example: '12.33'
          description: Delivery price (supports 2 decimal places)
        pickPrice:
          type: string
          example: '12.33'
          description: Pickup price (supports 2 decimal places)
        canteenPrice:
          type: string
          example: '12.33'
          description: Dine-in price (supports 2 decimal places)
        currency:
          type: string
          example: HKD
          description: >-
            Currency code (refer to "Currency Symbols" enum). Defaults to
            merchant's currency.
        status:
          type: integer
          example: 1
          description: |
            Availability status: 
              > 0:  indicates the ChoiceGroupSku is unavailable /
              > 1:  indicates ChoiceGroupSku is available
        openItemCode:
          type: string
          example: CHOICE#10001
          description: >-
            Third-party ChoiceGroupSku identifier. Mandatory and unique in
            OpenItemCode-based APIs.
        nutritionalInfo:
          type: object
          description: Nutritional components (refer to "Nutritional Elements" enum)
          additionalProperties:
            type: integer
        allergens:
          type: array
          description: Allergen information (refer to "Allergens" enum)
          items:
            type: string
        choiceGroupOpenItemCodeList:
          type: array
          description: >-
            OpenItemCodes of associated nested ChoiceGroups. Using this field
            for addons (items not sold separately on the menu, and cannot share
            the same name as any other SPU on the menu) with nested selection
            needs.
          items:
            type: string
        pictureList:
          type: array
          description: ChoiceGroupSku image URLs
          items:
            type: object
            required:
              - url
            properties:
              url:
                type: string
                example: >-
                  https://img-ap-hongkong.mykeeta.net/sailorproduct/9c760595674b395e330cf94b0e5068b09999.jpg
                description: ChoiceGroupSku image URLs
        relatedSpuOpenItemCode:
          type: string
          description: >-
            Third-party SPU identifier this ChoiceGroupSku should bind to. Using
            this to explicitly bind the ChoiceGroupSku to the given SPU.
        relatedSkuOpenItemCode:
          type: string
          description: >-
            Third-party SKU identifier this ChoiceGroupSku should bind to. Using
            this to explicitly bind the ChoiceGroupSku to the given SKU. When a
            ChoiceGroupSku bind to a SKU, it will use the bounded SKU's
            ChoiceGroups to form a multi-layer ChoiceGroup structure.
    CategoryProperty:
      type: object
      required:
        - propertyId
        - propertyValueList
      properties:
        propertyId:
          type: integer
          format: int64
          example: 9999
          description: Unique identifier for the property
        propertyName:
          type: string
          example: ''
          description: Display name of the property (e.g., "Size" for pizza)
        propertyType:
          type: integer
          example: 1
          description: |
            Property classification: 
          x-enumDescriptions:
            '1': indicates a standard property
            '2': indicates a sales property (currently unused)'
        minValueNumber:
          type: integer
          description: Minimum number of values that must be selected
        maxValueNumber:
          type: integer
          description: Maximum number of values that can be selected
        customizable:
          type: integer
          description: >-
            Custom value allowance: 0: customizable = 0 prohibits custom values
            1: customizable = 1 allows custom text input
        propertyValueList:
          type: array
          description: List of predefined property values
          items:
            $ref: '#/components/schemas/CategoryPropertyValue'
    CategoryPropertyValue:
      type: object
      required:
        - valueId
      properties:
        valueId:
          type: integer
          format: int64
          example: 9999
          description: Unique identifier for the property value
        valueName:
          type: string
          example: ''
          description: Display name of the property value (e.g., "Large" for pizza size)
    AvailableTime:
      type: object
      required:
        - code
      properties:
        code:
          type: integer
          example: 0
          description: |
            Selling time type indicator: 
          x-enumDescriptions:
            '0': indicates all-day availability
            '1': indicates weekly schedule
            '2': indicates specific date ranges
        values:
          type: array
          description: >-
            Required when code=1. Contains 7 strings representing daily time
            slots (Monday to Sunday). Empty string means unavailable.
          items:
            type: string
        available:
          type: array
          description: Defines specific date ranges and time windows. Required when code=2.
          items:
            $ref: '#/components/schemas/Availability'
    Availability:
      type: object
      properties:
        startTimestamp:
          type: integer
          format: int64
          example: 1735660800000
          description: >-
            Beginning timestamp (milliseconds). Required when using absolute
            date ranges. If set without endTimestamp, indicates perpetual
            availability after start date. Required when AvailableTime.code = 2
        endTimestamp:
          type: integer
          format: int64
          example: 1736956799000
          description: >-
            Ending timestamp (milliseconds). When omitted with startTimestamp,
            creates open-ended availability.
    DaysOfWeek:
      type: object
      properties:
        inWeek:
          type: array
          description: >-
            Days of week when product is available (1=Monday through 7=Sunday).
            Required when using weekly availability mode.
          items:
            type: integer
          example:
            - 1
            - 2
            - 3
            - 4
            - 5
            - 6
            - 7
        hoursOfDay:
          type: array
          description: >-
            This field contains the time slots during which a product is
            available for sale on a given day. Time slots must not overlap with
            each other. The system will reject the request if any overlapping
            periods are detected.
          items:
            $ref: '#/components/schemas/HoursOfDay'
    HoursOfDay:
      type: object
      properties:
        start:
          type: string
          example: '00:00'
          description: >-
            This field indicates the beginning time when a product becomes
            available for sale during a day. **Format**: "HH:mm" (24-hour format
            with leading zero)
        end:
          type: string
          example: '23:59'
          description: >-
            This field indicates the ending time when a product stops being
            available during a day. When left empty, the system **Format**:
            "HH:mm" (24-hour format with leading zero)
    Picture:
      type: object
      required:
        - url
      properties:
        url:
          type: string
          description: Product image URLs
    choiceGroupSkuPicture:
      type: object
      required:
        - url
      properties:
        url:
          type: string
          example: >-
            https://img-ap-hongkong.mykeeta.net/sailorproduct/9c760595674b395e330cf94b0e5068b09999.jpg
          description: ChoiceGroupSku image URLs
    ErrorSpu:
      type: object
      properties:
        id:
          type: integer
          format: int64
          description: >-
            Unique identifier for the SPU (Standard Product Unit), generated by
            Keeta's system
        name:
          type: string
          description: Display name of the SPU
        openItemCode:
          type: string
          example: VGsku-00035
          description: >-
            Developer-provided external identifier that maintains a one-to-one
            mapping with Keeta's internal SPU ID. Refer to the "Menu Development
            Guide" for implementation details.
        errorPictureList:
          type: array
          description: >-
            Contains information about failed image binding attempts during
            batch operations, including error details
          items:
            $ref: '#/components/schemas/ErrorPicture'
        code:
          type: integer
          description: >-
            A numeric status identifier indicating the result of the interface
            call, used to determine whether the operation executed successfully.
            **A code value of 0** indicates that **the request was executed
            successfully**. **Any non-zero code value** indicates that **request
            execution failed**. **Specific error details** can be viewed in the
            *message* field.
        message:
          type: string
          example: ''
          description: >-
            Text description corresponding to the status code, explaining the
            operation result or error cause to users.
    ErrorChoiceGroup:
      type: object
      properties:
        id:
          type: integer
          format: int64
          example: 45676543
          description: >-
            Unique identifier for the Choicegroup (Standard Product Unit),
            generated by Keeta's system
        name:
          type: string
          example: ''
          description: Display name of the Choicegroup
        openItemCode:
          type: string
          example: SET-11001000005-3
          description: >-
            Developer-provided external identifier that maintains a one-to-one
            mapping with Keeta's internal Choicegroup ID. Refer to the "Menu
            Development Guide" for implementation details.
        code:
          type: integer
          example: 107000104
          description: >-
            A numeric status identifier indicating the result of the interface
            call, used to determine whether the operation executed successfully.
            **A code value of 0** indicates that **the request was executed
            successfully**. **Any non-zero code value** indicates that **request
            execution failed**. **Specific error details** can be viewed in the
            *message* field.
        message:
          type: string
          example: Data does not exist
          description: >-
            Text description corresponding to the status code, explaining the
            operation result or error cause to users.
    ErrorPicture:
      type: object
      properties:
        url:
          type: string
          example: >-
            https://img-ap-hongkong.mykeeta.net/sailorproduct/9c760595674b395e330cf94b0e5068b09999.jpg
          description: Product image URLs
        code:
          type: integer
          description: >-
            A numeric status identifier indicating the result of the interface
            call, used to determine whether the operation executed successfully.
            **A code value of 0** indicates that **the request was executed
            successfully**. **Any non-zero code value** indicates that **request
            execution failed**. **Specific error details** can be viewed in the
            *message* field.
        message:
          type: string
          example: ''
          description: >-
            Text description corresponding to the status code, explaining the
            operation result or error cause to users.
    ChoiceGroupSkuCodePack:
      type: object
      required:
        - choiceGroupCode
        - choiceGroupSkuCodes
      properties:
        choiceGroupCode:
          type: string
          example: SET-77017010009-3
          description: >-
            The OpenItemCode identifier for the ChoiceGroup, provided by the
            developer.
        choiceGroupSkuCodes:
          type: array
          description: >-
            List of valid option OpenItemCodes that belong to the specified
            ChoiceGroup. All codes must exist within the given choiceGroupCode's
            option set.
          items:
            type: string
            example: 54ee29c7271d4ce18c5f8c63811e7ab1#77017010009#3#66026020003
    SpuMapping:
      type: object
      required:
        - name
        - openItemCode
        - skuList
        - languageType
      properties:
        name:
          type: string
          example: Spicy Beef Noodles
          description: Display name of the SPU
        openItemCode:
          type: string
          example: SPU#10001
          description: >-
            Developer-provided external identifier that maintains a one-to-one
            mapping with Keeta's internal spuId. Must be unique across all SPUs.
            For details, see Menu Integration Guide
        skuList:
          type: array
          description: >-
            List of SKUs associated with this SPU using OpenItemCode references
            For details, see Menu Integration Guide
          items:
            $ref: '#/components/schemas/SkuMapping'
        languageType:
          type: string
          example: en
          description: Language code for the name field
    SkuMapping:
      type: object
      required:
        - openItemCode
      properties:
        spec:
          type: string
          example: Big
          description: Display name of the SKU
        openItemCode:
          type: string
          example: '1582'
          description: >-
            Developer-provided external identifier that maintains a one-to-one
            mapping with Keeta's internal skuId. Must be unique across all SKUs.
            For details, see Menu Integration Guide
    ErrorShopCategory:
      type: object
      properties:
        id:
          type: integer
          format: int64
          description: Unique Category ID generated by Keeta.
        code:
          type: integer
          description: >-
            A numeric status identifier indicating the result of the interface
            call, used to determine whether the operation executed successfully.
            **A code value of 0** indicates that **the request was executed
            successfully**. **Any non-zero code value** indicates that **request
            execution failed**. **Specific error details** can be viewed in the
            *message* field.
        message:
          type: string
          example: ''
          description: >-
            Text description corresponding to the status code, explaining the
            operation result or error cause to users.
    ConflictGroup:
      type: object
      properties:
        spuId:
          type: integer
          format: int64
          description: Unique SPU ID generated by Keeta.
        choiceGroupIdList:
          type: array
          description: >-
            Contains the IDs of choice groups that have rule conflicts with this
            SPU.
          items:
            type: integer
            format: int64
    SimpleSpu:
      type: object
      properties:
        id:
          type: integer
          format: int64
          description: Unique identifier for the SPU, generated by Keeta system.
        name:
          type: string
          description: Display name of the SPU.
        status:
          type: integer
          description: |
            Sales availability status of the SPU:
          x-enumDescriptions:
            '0': indicates the SPU is **not available** for sale
            '1': indicates the SPU is **available** for sale
    OpenShopCategorySequenceDTO:
      type: object
      properties:
        shopCategoryId:
          type: integer
          format: int64
          example: 5675
          description: Unique Category ID generated by Keeta system.
        sequence:
          type: integer
          example: 345454657
          description: >-
            Determines the sorting position of the category in menu displays.
            Uses 1-based indexing (1 = first position).
    OpenSpuSequenceDTO:
      type: object
      properties:
        spuId:
          type: integer
          format: int64
          description: Unique identifier for the SPU, generated by Keeta system.
        sequence:
          type: integer
          description: >-
            Determines the sorting position of the SPU in menu displays. Uses
            1-based indexing (1 = first position). Lower numbers appear before
            higher numbers.
    ChoiceGroupAppliedSpu:
      type: object
      properties:
        choiceGroupId:
          type: integer
          format: int64
          description: Unique Choicegroup ID generated by Keeta.
        list:
          type: array
          description: >-
            A list of SPUs (Standard Product Units) that currently utilize this
            choice group in their configurations.
          items:
            $ref: '#/components/schemas/SimpleSpu'
    ChoiceGroupSkuIdPack:
      type: object
      properties:
        choiceGroupId:
          type: integer
          format: int64
          description: Unique identifier for the choice group, generated by Keeta system
        choiceGroupSkuIds:
          type: array
          description: List of ChoiceGroupSku IDs that belong to the specified choice group
          items:
            type: integer
            format: int64
    SpuPicture:
      type: object
      properties:
        spuId:
          type: integer
          format: int64
          description: Unique identifier for the SPU, generated by Keeta system.
        urlList:
          type: array
          description: List of external image URLs associated with the product.
          items:
            type: string
tags:
  - name: OpenItemCode-Based
  - name: Webhooks
  - name: KeetaID-Based
  - name: Product Picture
