/* generated using openapi-typescript-codegen -- do not edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { Body_parse_deals_excel } from '../models/Body_parse_deals_excel';
import type { CardAddKitRequest } from '../models/CardAddKitRequest';
import type { CardAddKitResponse } from '../models/CardAddKitResponse';
import type { CardAddProductRequest } from '../models/CardAddProductRequest';
import type { CardAddProductResponse } from '../models/CardAddProductResponse';
import type { CardAddServiceRequest } from '../models/CardAddServiceRequest';
import type { CardAddServiceResponse } from '../models/CardAddServiceResponse';
import type { CardAddServicesRequest } from '../models/CardAddServicesRequest';
import type { CardAddServicesResponse } from '../models/CardAddServicesResponse';
import type { CardChangeStatusRequest } from '../models/CardChangeStatusRequest';
import type { CardChangeStatusResponse } from '../models/CardChangeStatusResponse';
import type { CardCompleteRequest } from '../models/CardCompleteRequest';
import type { CardCompleteResponse } from '../models/CardCompleteResponse';
import type { CardCreateGuestUrlRequest } from '../models/CardCreateGuestUrlRequest';
import type { CardCreateGuestUrlResponse } from '../models/CardCreateGuestUrlResponse';
import type { CardDeleteProductRequest } from '../models/CardDeleteProductRequest';
import type { CardDeleteProductResponse } from '../models/CardDeleteProductResponse';
import type { CardDeleteProductsRequest } from '../models/CardDeleteProductsRequest';
import type { CardDeleteProductsResponse } from '../models/CardDeleteProductsResponse';
import type { CardDeleteRequest } from '../models/CardDeleteRequest';
import type { CardDeleteResponse } from '../models/CardDeleteResponse';
import type { CardDeleteServiceRequest } from '../models/CardDeleteServiceRequest';
import type { CardDeleteServiceResponse } from '../models/CardDeleteServiceResponse';
import type { CardDeleteServicesRequest } from '../models/CardDeleteServicesRequest';
import type { CardDeleteServicesResponse } from '../models/CardDeleteServicesResponse';
import type { CardGetAllResponse } from '../models/CardGetAllResponse';
import type { CardPrefillRequest } from '../models/CardPrefillRequest';
import type { CardPrefillResponse } from '../models/CardPrefillResponse';
import type { CardProductAddKitRequest } from '../models/CardProductAddKitRequest';
import type { CardProductAddKitResponse } from '../models/CardProductAddKitResponse';
import type { CardQuickCreateRequest } from '../models/CardQuickCreateRequest';
import type { CardQuickCreateResponse } from '../models/CardQuickCreateResponse';
import type { CardRecalculatePriceRequest } from '../models/CardRecalculatePriceRequest';
import type { CardRecalculatePriceResponse } from '../models/CardRecalculatePriceResponse';
import type { CardSchema } from '../models/CardSchema';
import type { CardServicesCopyRequest } from '../models/CardServicesCopyRequest';
import type { CardServicesCopyResponse } from '../models/CardServicesCopyResponse';
import type { CardSummaryReorderRequest } from '../models/CardSummaryReorderRequest';
import type { CardSummaryResponse } from '../models/CardSummaryResponse';
import type { CardUpdateGeneralInfoRequest } from '../models/CardUpdateGeneralInfoRequest';
import type { CardUpdateGeneralInfoResponse } from '../models/CardUpdateGeneralInfoResponse';
import type { CardUpdateProductQuantityRequest } from '../models/CardUpdateProductQuantityRequest';
import type { CardUpdateProductQuantityResponse } from '../models/CardUpdateProductQuantityResponse';
import type { CardUpdateProductRequest } from '../models/CardUpdateProductRequest';
import type { CardUpdateProductResponse } from '../models/CardUpdateProductResponse';
import type { CardUpdateServiceQuantityRequest } from '../models/CardUpdateServiceQuantityRequest';
import type { CardUpdateServiceQuantityResponse } from '../models/CardUpdateServiceQuantityResponse';
import type { CardUpdateServiceRequest } from '../models/CardUpdateServiceRequest';
import type { CardUpdateServiceResponse } from '../models/CardUpdateServiceResponse';
import type { CreateCardsFromExcelRequest } from '../models/CreateCardsFromExcelRequest';
import type { CreateCardsFromExcelResponse } from '../models/CreateCardsFromExcelResponse';
import type { GetAvailableEmployeesToAssignResponse } from '../models/GetAvailableEmployeesToAssignResponse';
import type { GetCardProductsBarcodesPdfRequest } from '../models/GetCardProductsBarcodesPdfRequest';
import type { GetCardProductsBarcodesPdfResponse } from '../models/GetCardProductsBarcodesPdfResponse';
import type { ManageEmployeeRequest } from '../models/ManageEmployeeRequest';
import type { ManageEmployeeResponse } from '../models/ManageEmployeeResponse';
import type { ParseCardsExcelResponse } from '../models/ParseCardsExcelResponse';
import type { ProductsAndServicesGeneralInfoRequest } from '../models/ProductsAndServicesGeneralInfoRequest';
import type { ProductsAndServicesGeneralInfoResponse } from '../models/ProductsAndServicesGeneralInfoResponse';
import type { UpdateCardClientRequest } from '../models/UpdateCardClientRequest';
import type { UpdateCardClientResponse } from '../models/UpdateCardClientResponse';
import type { UpdateCardManagerRequest } from '../models/UpdateCardManagerRequest';
import type { UpdateCardManagerResponse } from '../models/UpdateCardManagerResponse';
import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';
export class CardService {
    /**
     * Delete
     * @returns CardDeleteResponse Successful Response
     * @throws ApiError
     */
    public static deleteCard({
        requestBody,
    }: {
        requestBody: CardDeleteRequest,
    }): CancelablePromise<CardDeleteResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/delete',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Complete
     * @returns CardCompleteResponse Successful Response
     * @throws ApiError
     */
    public static completeCard({
        requestBody,
    }: {
        requestBody: CardCompleteRequest,
    }): CancelablePromise<CardCompleteResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/complete',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Quick Create
     * @returns CardQuickCreateResponse Successful Response
     * @throws ApiError
     */
    public static quickCreateCardQuickCreatePost({
        requestBody,
    }: {
        requestBody: CardQuickCreateRequest,
    }): CancelablePromise<CardQuickCreateResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/quickCreate',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Change Status
     * @returns CardChangeStatusResponse Successful Response
     * @throws ApiError
     */
    public static changeStatusCardChangeStatusPost({
        requestBody,
    }: {
        requestBody: CardChangeStatusRequest,
    }): CancelablePromise<CardChangeStatusResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/changeStatus',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get Summary
     * @returns CardSummaryResponse Successful Response
     * @throws ApiError
     */
    public static getCardSummaries({
        full,
    }: {
        full: (boolean | null),
    }): CancelablePromise<CardSummaryResponse> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/summaries',
            query: {
                'full': full,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Reorder
     * @returns CardSummaryResponse Successful Response
     * @throws ApiError
     */
    public static reorderCardSummaries({
        requestBody,
    }: {
        requestBody: CardSummaryReorderRequest,
    }): CancelablePromise<CardSummaryResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/summaries/reorder',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get All
     * @returns CardGetAllResponse Successful Response
     * @throws ApiError
     */
    public static getAllCards(): CancelablePromise<CardGetAllResponse> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/get-all',
        });
    }
    /**
     * Get Card By Id
     * @returns CardSchema Successful Response
     * @throws ApiError
     */
    public static getCardById({
        cardId,
    }: {
        cardId: number,
    }): CancelablePromise<CardSchema> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/get/{card_id}',
            path: {
                'card_id': cardId,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Update General Info
     * @returns CardUpdateGeneralInfoResponse Successful Response
     * @throws ApiError
     */
    public static updateCardGeneralInfo({
        requestBody,
    }: {
        requestBody: CardUpdateGeneralInfoRequest,
    }): CancelablePromise<CardUpdateGeneralInfoResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/update-general-info',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Update Products And Services General Info
     * @returns ProductsAndServicesGeneralInfoResponse Successful Response
     * @throws ApiError
     */
    public static updateProductsAndServicesGeneralInfo({
        requestBody,
    }: {
        requestBody: ProductsAndServicesGeneralInfoRequest,
    }): CancelablePromise<ProductsAndServicesGeneralInfoResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/update-products-and-services-general-info',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Update Card Manager
     * @returns UpdateCardManagerResponse Successful Response
     * @throws ApiError
     */
    public static updateCardManager({
        requestBody,
    }: {
        requestBody: UpdateCardManagerRequest,
    }): CancelablePromise<UpdateCardManagerResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/update-card-manager',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Update Card Client
     * @returns UpdateCardClientResponse Successful Response
     * @throws ApiError
     */
    public static updateCardClient({
        requestBody,
    }: {
        requestBody: UpdateCardClientRequest,
    }): CancelablePromise<UpdateCardClientResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/update-card-client',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Add Kit To Card
     * @returns CardAddKitResponse Successful Response
     * @throws ApiError
     */
    public static addKitToCard({
        requestBody,
    }: {
        requestBody: CardAddKitRequest,
    }): CancelablePromise<CardAddKitResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/add-kit',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Create Guest Url
     * @returns CardCreateGuestUrlResponse Successful Response
     * @throws ApiError
     */
    public static createDealGuestUrl({
        requestBody,
    }: {
        requestBody: CardCreateGuestUrlRequest,
    }): CancelablePromise<CardCreateGuestUrlResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/create-guest-url',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get Billing Document
     * @returns any Successful Response
     * @throws ApiError
     */
    public static getBillingDocument({
        dealId,
    }: {
        dealId: number,
    }): CancelablePromise<any> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/billing-document/{deal_id}',
            path: {
                'deal_id': dealId,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get Deal Tech Spec
     * @returns any Successful Response
     * @throws ApiError
     */
    public static getDealTechSpec({
        dealId,
    }: {
        dealId: number,
    }): CancelablePromise<any> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/tech-spec/{deal_id}',
            path: {
                'deal_id': dealId,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Post Prefill Card
     * @returns CardPrefillResponse Successful Response
     * @throws ApiError
     */
    public static prefillCard({
        requestBody,
    }: {
        requestBody: CardPrefillRequest,
    }): CancelablePromise<CardPrefillResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/prefill',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Recalculate Card Price
     * @returns CardRecalculatePriceResponse Successful Response
     * @throws ApiError
     */
    public static recalculateCardPrice({
        requestBody,
    }: {
        requestBody: CardRecalculatePriceRequest,
    }): CancelablePromise<CardRecalculatePriceResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/recalculate-price',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Manage Employee
     * @returns ManageEmployeeResponse Successful Response
     * @throws ApiError
     */
    public static manageEmployee({
        requestBody,
    }: {
        requestBody: ManageEmployeeRequest,
    }): CancelablePromise<ManageEmployeeResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/employee',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get Available Employees To Assign
     * @returns GetAvailableEmployeesToAssignResponse Successful Response
     * @throws ApiError
     */
    public static getAvailableEmployeesToAssign({
        cardId,
    }: {
        cardId: number,
    }): CancelablePromise<GetAvailableEmployeesToAssignResponse> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/card/employee/available/{card_id}',
            path: {
                'card_id': cardId,
            },
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Parse Deals Excel
     * @returns ParseCardsExcelResponse Successful Response
     * @throws ApiError
     */
    public static parseDealsExcel({
        formData,
    }: {
        formData: Body_parse_deals_excel,
    }): CancelablePromise<ParseCardsExcelResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/prefill/excel/parse',
            formData: formData,
            mediaType: 'multipart/form-data',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Create Deals From Excel
     * @returns CreateCardsFromExcelResponse Successful Response
     * @throws ApiError
     */
    public static createDealsExcel({
        requestBody,
    }: {
        requestBody: CreateCardsFromExcelRequest,
    }): CancelablePromise<CreateCardsFromExcelResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/prefill/excel/create',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Add
     * @returns CardAddServicesResponse Successful Response
     * @throws ApiError
     */
    public static addMultipleCardServices({
        requestBody,
    }: {
        requestBody: CardAddServicesRequest,
    }): CancelablePromise<CardAddServicesResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/add/multiple',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Add
     * @returns CardAddServiceResponse Successful Response
     * @throws ApiError
     */
    public static addCardService({
        requestBody,
    }: {
        requestBody: CardAddServiceRequest,
    }): CancelablePromise<CardAddServiceResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/add',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Update Quantity
     * @returns CardUpdateServiceQuantityResponse Successful Response
     * @throws ApiError
     */
    public static updateCardServiceQuantity({
        requestBody,
    }: {
        requestBody: CardUpdateServiceQuantityRequest,
    }): CancelablePromise<CardUpdateServiceQuantityResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/update-quantity',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Update
     * @returns CardUpdateServiceResponse Successful Response
     * @throws ApiError
     */
    public static updateCardService({
        requestBody,
    }: {
        requestBody: CardUpdateServiceRequest,
    }): CancelablePromise<CardUpdateServiceResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/update',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Delete
     * @returns CardDeleteServiceResponse Successful Response
     * @throws ApiError
     */
    public static deleteCardService({
        requestBody,
    }: {
        requestBody: CardDeleteServiceRequest,
    }): CancelablePromise<CardDeleteServiceResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/delete',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Delete
     * @returns CardDeleteServicesResponse Successful Response
     * @throws ApiError
     */
    public static deleteMultipleCardServices({
        requestBody,
    }: {
        requestBody: CardDeleteServicesRequest,
    }): CancelablePromise<CardDeleteServicesResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/delete/multiple',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Services Copy
     * @returns CardServicesCopyResponse Successful Response
     * @throws ApiError
     */
    public static copyProductServices({
        requestBody,
    }: {
        requestBody: CardServicesCopyRequest,
    }): CancelablePromise<CardServicesCopyResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/services/copy',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Products Update
     * @returns CardUpdateProductQuantityResponse Successful Response
     * @throws ApiError
     */
    public static updateCardProductQuantity({
        requestBody,
    }: {
        requestBody: CardUpdateProductQuantityRequest,
    }): CancelablePromise<CardUpdateProductQuantityResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/products/update-quantity',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Products Add
     * @returns CardAddProductResponse Successful Response
     * @throws ApiError
     */
    public static addCardProduct({
        requestBody,
    }: {
        requestBody: CardAddProductRequest,
    }): CancelablePromise<CardAddProductResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/products/add',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Products Delete
     * @returns CardDeleteProductResponse Successful Response
     * @throws ApiError
     */
    public static deleteCardProduct({
        requestBody,
    }: {
        requestBody: CardDeleteProductRequest,
    }): CancelablePromise<CardDeleteProductResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/products/delete',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Products Delete
     * @returns CardDeleteProductsResponse Successful Response
     * @throws ApiError
     */
    public static deleteMultipleCardProducts({
        requestBody,
    }: {
        requestBody: CardDeleteProductsRequest,
    }): CancelablePromise<CardDeleteProductsResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/products/delete/multiple',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Products Update
     * @returns CardUpdateProductResponse Successful Response
     * @throws ApiError
     */
    public static updateCardProduct({
        requestBody,
    }: {
        requestBody: CardUpdateProductRequest,
    }): CancelablePromise<CardUpdateProductResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/product/update',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Add Kit To Card Product
     * @returns CardProductAddKitResponse Successful Response
     * @throws ApiError
     */
    public static addKitToCardProduct({
        requestBody,
    }: {
        requestBody: CardProductAddKitRequest,
    }): CancelablePromise<CardProductAddKitResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/product/add-kit',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
    /**
     * Get Card Products Barcodes Pdf
     * @returns GetCardProductsBarcodesPdfResponse Successful Response
     * @throws ApiError
     */
    public static getCardProductsBarcodesPdf({
        requestBody,
    }: {
        requestBody: GetCardProductsBarcodesPdfRequest,
    }): CancelablePromise<GetCardProductsBarcodesPdfResponse> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/card/barcodes/get-pdf',
            body: requestBody,
            mediaType: 'application/json',
            errors: {
                422: `Validation Error`,
            },
        });
    }
}
