@drttix/drt-sdk 1.2.1 → 1.2.2

package/src/generated/portal/services/FeaturesProductsService.ts

@@ -1,441 +1,516 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CreateProductResponseDto } from '../models/CreateProductResponseDto';
-import type { CreateProductVariantRequestDto } from '../models/CreateProductVariantRequestDto';
-import type { createServiceAgreementRequestDto } from '../models/createServiceAgreementRequestDto';
-import type { CreateUpdateProductRequestDto } from '../models/CreateUpdateProductRequestDto';
-import type { DeleteProductVariantRequestDto } from '../models/DeleteProductVariantRequestDto';
-import type { DuplicateProductRequestDto } from '../models/DuplicateProductRequestDto';
-import type { IconShowGroupResponseDto } from '../models/IconShowGroupResponseDto';
-import type { ProductDetailResponseDto } from '../models/ProductDetailResponseDto';
-import type { ProductListResponseDto } from '../models/ProductListResponseDto';
-import type { ProductRecipientResponseDto } from '../models/ProductRecipientResponseDto';
-import type { ProductSalesResponseDto } from '../models/ProductSalesResponseDto';
-import type { ProductSendMailRequestDto } from '../models/ProductSendMailRequestDto';
-import type { ProductVariantResponseDto } from '../models/ProductVariantResponseDto';
-import type { StartImageUploadRequestDto } from '../models/StartImageUploadRequestDto';
-import type { StartImageUploadResponseDto } from '../models/StartImageUploadResponseDto';
-import type { SuccessResponse } from '../models/SuccessResponse';
-import type { UpdateImageUploadRequestDto } from '../models/UpdateImageUploadRequestDto';
-import type { UpdateProductVariantRequestDto } from '../models/UpdateProductVariantRequestDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class FeaturesProductsService {
-    /**
-     * Fetch the products list
-     * Fetch the list of products
-     * @param xStudioId The ID of the studio
-     * @returns ProductListResponseDto Products fetched successfully
-     * @throws ApiError
-     */
-    public static getProducts(
-        xStudioId: string,
-    ): CancelablePromise<Array<ProductListResponseDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Create the product
-     * Create a new product for the given studio ID
-     * @param xStudioId The ID of the studio
-     * @param requestBody Payload to create product
-     * @returns CreateProductResponseDto Product created successfully
-     * @throws ApiError
-     */
-    public static createProduct(
-        xStudioId: string,
-        requestBody: CreateUpdateProductRequestDto,
-    ): CancelablePromise<CreateProductResponseDto> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Fetch the icons and show groups
-     * Fetch the list of icons and show groups
-     * @param xStudioId The ID of the studio
-     * @returns IconShowGroupResponseDto Icons and show groups fetched successfully
-     * @throws ApiError
-     */
-    public static getIconsShowGroups(
-        xStudioId: string,
-    ): CancelablePromise<Array<IconShowGroupResponseDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/icons-show-groups',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Fetch the product sales
-     * Fetch the sales of product
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @returns ProductSalesResponseDto Product sales fetched successfully
-     * @throws ApiError
-     */
-    public static getProductSales(
-        xStudioId: string,
-        productId: string,
-    ): CancelablePromise<ProductSalesResponseDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/{productId}/sales',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Validate the service agreement exist or not
-     * Check if the service agreement exists for the given studio ID
-     * @param xStudioId The ID of the studio
-     * @returns SuccessResponse Service agreement fetched successfully
-     * @throws ApiError
-     */
-    public static getServiceAgreement(
-        xStudioId: string,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/service-agreement',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Create the service agreement
-     * Create a new service agreement for the given studio ID
-     * @param xStudioId The ID of the studio
-     * @param requestBody Payload to create service agreement
-     * @returns SuccessResponse Service agreement created successfully
-     * @throws ApiError
-     */
-    public static createServiceAgreement(
-        xStudioId: string,
-        requestBody: createServiceAgreementRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products/service-agreement',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Fetch the product details
-     * Fetch the sales of details
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @returns ProductDetailResponseDto Product details fetched successfully
-     * @throws ApiError
-     */
-    public static getProductDetails(
-        xStudioId: string,
-        productId: string,
-    ): CancelablePromise<ProductDetailResponseDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/{productId}',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Update the product
-     * Update the product for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId
-     * @param requestBody Payload to update product
-     * @returns SuccessResponse Product updated successfully
-     * @throws ApiError
-     */
-    public static updateProduct(
-        xStudioId: string,
-        productId: string,
-        requestBody: CreateUpdateProductRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/features/products/{productId}',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Delete the product
-     * Delete the product for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId
-     * @returns SuccessResponse Product deleted successfully
-     * @throws ApiError
-     */
-    public static deleteProduct(
-        xStudioId: string,
-        productId: string,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/features/products/{productId}',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Fetch the product recipients
-     * Fetch the recipients of product
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @returns ProductRecipientResponseDto Product recipients fetched successfully
-     * @throws ApiError
-     */
-    public static getProductRecipients(
-        xStudioId: string,
-        productId: string,
-    ): CancelablePromise<Array<ProductRecipientResponseDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/{productId}/recipients',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Fetch the product variants
-     * Fetch the variants of product
-     * @param productId The ID of the product
-     * @returns ProductVariantResponseDto Product variants fetched successfully
-     * @throws ApiError
-     */
-    public static getProductVariants(
-        productId: string,
-    ): CancelablePromise<Array<ProductVariantResponseDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/features/products/{productId}/variants',
-            path: {
-                'productId': productId,
-            },
-        });
-    }
-    /**
-     * Start image upload
-     * Start a new image upload for the given studio ID
-     * @param xStudioId The ID of the studio
-     * @param requestBody Payload to start image upload
-     * @returns StartImageUploadResponseDto Image upload started successfully
-     * @throws ApiError
-     */
-    public static startImageUpload(
-        xStudioId: string,
-        requestBody: StartImageUploadRequestDto,
-    ): CancelablePromise<StartImageUploadResponseDto> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products/start-image-upload',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Create the duplicate product
-     * Create a new duplicate product for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId
-     * @param requestBody Payload to create duplicate product
-     * @returns SuccessResponse Duplicate product created successfully
-     * @throws ApiError
-     */
-    public static createDuplicateProduct(
-        xStudioId: string,
-        productId: string,
-        requestBody: DuplicateProductRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products/{productId}/duplicate',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Send mail for the product
-     * Send mail for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @param requestBody Payload to send mail for product
-     * @returns SuccessResponse Mail sent successfully
-     * @throws ApiError
-     */
-    public static sendEmail(
-        xStudioId: string,
-        productId: string,
-        requestBody: ProductSendMailRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products/{productId}/send-mail',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Create variant for the product
-     * Create variant for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @param requestBody Payload to create variant for product
-     * @returns SuccessResponse Variant created successfully
-     * @throws ApiError
-     */
-    public static createVariant(
-        xStudioId: string,
-        productId: string,
-        requestBody: CreateProductVariantRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/features/products/{productId}/create-variant',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Update image url for the product
-     * Update image url for the given product ID
-     * @param productId The ID of the product
-     * @param xStudioId The ID of the studio
-     * @param requestBody Payload to update image url for product
-     * @returns SuccessResponse Image url updated successfully
-     * @throws ApiError
-     */
-    public static updateImageUrl(
-        productId: string,
-        xStudioId: string,
-        requestBody: UpdateImageUploadRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/features/products/{productId}/update-image-url',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Update variant for the product
-     * Update variant for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param productId The ID of the product
-     * @param requestBody Payload to update variant for product
-     * @returns SuccessResponse Variant updated successfully
-     * @throws ApiError
-     */
-    public static updateVariant(
-        xStudioId: string,
-        productId: string,
-        requestBody: UpdateProductVariantRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/features/products/{productId}/update-variant',
-            path: {
-                'productId': productId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Delete the product
-     * Delete the product for the given product ID
-     * @param xStudioId The ID of the studio
-     * @param requestBody Payload to update product
-     * @returns SuccessResponse Product deleted successfully
-     * @throws ApiError
-     */
-    public static deleteProduct1(
-        xStudioId: string,
-        requestBody: DeleteProductVariantRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/features/products/variant',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CreateProductReminderRequestDto } from '../models/CreateProductReminderRequestDto';
+import type { CreateProductResponseDto } from '../models/CreateProductResponseDto';
+import type { CreateProductVariantRequestDto } from '../models/CreateProductVariantRequestDto';
+import type { createServiceAgreementRequestDto } from '../models/createServiceAgreementRequestDto';
+import type { CreateUpdateProductRequestDto } from '../models/CreateUpdateProductRequestDto';
+import type { DeleteProductVariantRequestDto } from '../models/DeleteProductVariantRequestDto';
+import type { DuplicateProductRequestDto } from '../models/DuplicateProductRequestDto';
+import type { IconShowGroupResponseDto } from '../models/IconShowGroupResponseDto';
+import type { ProductDetailResponseDto } from '../models/ProductDetailResponseDto';
+import type { ProductListResponseDto } from '../models/ProductListResponseDto';
+import type { ProductRecipientResponseDto } from '../models/ProductRecipientResponseDto';
+import type { ProductReminderResponseDto } from '../models/ProductReminderResponseDto';
+import type { ProductSalesResponseDto } from '../models/ProductSalesResponseDto';
+import type { ProductSendMailRequestDto } from '../models/ProductSendMailRequestDto';
+import type { ProductVariantResponseDto } from '../models/ProductVariantResponseDto';
+import type { StartImageUploadRequestDto } from '../models/StartImageUploadRequestDto';
+import type { StartImageUploadResponseDto } from '../models/StartImageUploadResponseDto';
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { UpdateImageUploadRequestDto } from '../models/UpdateImageUploadRequestDto';
+import type { UpdateProductReminderRequestDto } from '../models/UpdateProductReminderRequestDto';
+import type { UpdateProductVariantRequestDto } from '../models/UpdateProductVariantRequestDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class FeaturesProductsService {
+    /**
+     * Fetch the products list
+     * Fetch the list of products
+     * @param xStudioId The ID of the studio
+     * @returns ProductListResponseDto Products fetched successfully
+     * @throws ApiError
+     */
+    public static getProducts(
+        xStudioId: string,
+    ): CancelablePromise<Array<ProductListResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Create the product
+     * Create a new product for the given studio ID
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to create product
+     * @returns CreateProductResponseDto Product created successfully
+     * @throws ApiError
+     */
+    public static createProduct(
+        xStudioId: string,
+        requestBody: CreateUpdateProductRequestDto,
+    ): CancelablePromise<CreateProductResponseDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Fetch the icons and show groups
+     * Fetch the list of icons and show groups
+     * @param xStudioId The ID of the studio
+     * @returns IconShowGroupResponseDto Icons and show groups fetched successfully
+     * @throws ApiError
+     */
+    public static getIconsShowGroups(
+        xStudioId: string,
+    ): CancelablePromise<Array<IconShowGroupResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/icons-show-groups',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Fetch the product sales
+     * Fetch the sales of product
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @returns ProductSalesResponseDto Product sales fetched successfully
+     * @throws ApiError
+     */
+    public static getProductSales(
+        xStudioId: string,
+        productId: string,
+    ): CancelablePromise<ProductSalesResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/{productId}/sales',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Validate the service agreement exist or not
+     * Check if the service agreement exists for the given studio ID
+     * @param xStudioId The ID of the studio
+     * @returns SuccessResponse Service agreement fetched successfully
+     * @throws ApiError
+     */
+    public static getServiceAgreement(
+        xStudioId: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/service-agreement',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Create the service agreement
+     * Create a new service agreement for the given studio ID
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to create service agreement
+     * @returns SuccessResponse Service agreement created successfully
+     * @throws ApiError
+     */
+    public static createServiceAgreement(
+        xStudioId: string,
+        requestBody: createServiceAgreementRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/service-agreement',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Fetch the product details
+     * Fetch the sales of details
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @returns ProductDetailResponseDto Product details fetched successfully
+     * @throws ApiError
+     */
+    public static getProductDetails(
+        xStudioId: string,
+        productId: string,
+    ): CancelablePromise<ProductDetailResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/{productId}',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Update the product
+     * Update the product for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId
+     * @param requestBody Payload to update product
+     * @returns SuccessResponse Product updated successfully
+     * @throws ApiError
+     */
+    public static updateProduct(
+        xStudioId: string,
+        productId: string,
+        requestBody: CreateUpdateProductRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/products/{productId}',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete the product
+     * Delete the product for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId
+     * @returns SuccessResponse Product deleted successfully
+     * @throws ApiError
+     */
+    public static deleteProduct(
+        xStudioId: string,
+        productId: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/features/products/{productId}',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Fetch the product recipients
+     * Fetch the recipients of product
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @returns ProductRecipientResponseDto Product recipients fetched successfully
+     * @throws ApiError
+     */
+    public static getProductRecipients(
+        xStudioId: string,
+        productId: string,
+    ): CancelablePromise<Array<ProductRecipientResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/{productId}/recipients',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Fetch the product variants
+     * Fetch the variants of product
+     * @param productId The ID of the product
+     * @returns ProductVariantResponseDto Product variants fetched successfully
+     * @throws ApiError
+     */
+    public static getProductVariants(
+        productId: string,
+    ): CancelablePromise<Array<ProductVariantResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/{productId}/variants',
+            path: {
+                'productId': productId,
+            },
+        });
+    }
+    /**
+     * Fetch the product reminders
+     * Fetch the reminders of product
+     * @param productId The ID of the product
+     * @returns ProductReminderResponseDto Product reminders fetched successfully
+     * @throws ApiError
+     */
+    public static getProductReminders(
+        productId: string,
+    ): CancelablePromise<Array<ProductReminderResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/products/{productId}/reminders',
+            path: {
+                'productId': productId,
+            },
+        });
+    }
+    /**
+     * Start image upload
+     * Start a new image upload for the given studio ID
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to start image upload
+     * @returns StartImageUploadResponseDto Image upload started successfully
+     * @throws ApiError
+     */
+    public static startImageUpload(
+        xStudioId: string,
+        requestBody: StartImageUploadRequestDto,
+    ): CancelablePromise<StartImageUploadResponseDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/start-image-upload',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create the duplicate product
+     * Create a new duplicate product for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId
+     * @param requestBody Payload to create duplicate product
+     * @returns SuccessResponse Duplicate product created successfully
+     * @throws ApiError
+     */
+    public static createDuplicateProduct(
+        xStudioId: string,
+        productId: string,
+        requestBody: DuplicateProductRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/{productId}/duplicate',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Send mail for the product
+     * Send mail for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @param requestBody Payload to send mail for product
+     * @returns SuccessResponse Mail sent successfully
+     * @throws ApiError
+     */
+    public static sendEmail(
+        xStudioId: string,
+        productId: string,
+        requestBody: ProductSendMailRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/{productId}/send-mail',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create variant for the product
+     * Create variant for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @param requestBody Payload to create variant for product
+     * @returns SuccessResponse Variant created successfully
+     * @throws ApiError
+     */
+    public static createVariant(
+        xStudioId: string,
+        productId: string,
+        requestBody: CreateProductVariantRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/{productId}/create-variant',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create reminder for the product
+     * Create reminder for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @param requestBody Payload to create reminder for product
+     * @returns SuccessResponse Reminder created successfully
+     * @throws ApiError
+     */
+    public static createReminder(
+        xStudioId: string,
+        productId: string,
+        requestBody: CreateProductReminderRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/products/{productId}/create-reminder',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update image url for the product
+     * Update image url for the given product ID
+     * @param productId The ID of the product
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update image url for product
+     * @returns SuccessResponse Image url updated successfully
+     * @throws ApiError
+     */
+    public static updateImageUrl(
+        productId: string,
+        xStudioId: string,
+        requestBody: UpdateImageUploadRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/products/{productId}/update-image-url',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update variant for the product
+     * Update variant for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @param requestBody Payload to update variant for product
+     * @returns SuccessResponse Variant updated successfully
+     * @throws ApiError
+     */
+    public static updateVariant(
+        xStudioId: string,
+        productId: string,
+        requestBody: UpdateProductVariantRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/products/{productId}/update-variant',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update reminder for the product
+     * Update reminder for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param productId The ID of the product
+     * @param requestBody Payload to update reminder for product
+     * @returns SuccessResponse Reminder updated successfully
+     * @throws ApiError
+     */
+    public static updateReminder(
+        xStudioId: string,
+        productId: string,
+        requestBody: UpdateProductReminderRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/products/{productId}/update-reminder',
+            path: {
+                'productId': productId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete the product
+     * Delete the product for the given product ID
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update product
+     * @returns SuccessResponse Product deleted successfully
+     * @throws ApiError
+     */
+    public static deleteProduct1(
+        xStudioId: string,
+        requestBody: DeleteProductVariantRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/features/products/variant',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}