mb-apimatic-sdk 1.0.0

data/lib/mindbody_public_api/controllers/sale_controller.rb

@@ -0,0 +1,1226 @@
+# mindbody_public_api
+#
+# This file was automatically generated by APIMATIC
+# v3.0 ( https://www.apimatic.io ).
+
+module MindbodyPublicApi
+  # SaleController
+  class SaleController < BaseController
+    # Gets a list of card types that the site accepts. You can also use `GET
+    # Sites` to return the Site object, which contains individual accepted card
+    # types for requested sites.
+    # This endpoint has no query parameters.The response returns a list of
+    # strings. Possible values are:
+    # * Visa
+    # * MasterCard
+    # * Discover
+    # * AMEX
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [Array[String]] Response from the API call.
+    def get_accepted_card_types(version,
+                                site_id,
+                                authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/acceptedcardtypes',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:deserialize_primitive_types))
+                    .is_response_array(true)
+                    .is_primitive_response(true))
+        .execute
+    end
+
+    # Get alternative and local payment methods that are allowed for a site.
+    # These payment methods can later be used in `Initiate Checkout Shopping
+    # Cart Using Alternative Payments`
+    # and `Initiate Purchase Contract Using Alternative Payments` to make the
+    # payment.
+    # 
+    # The currently supported alternative payments are:
+    # - iDEAL
+    # - Apple Pay
+    # **Notes:**
+    # - This endpoint is only available for Studios on MBPS (Mindbody Payments)
+    # with Stripe payment processor.
+    # - This endpoint only supports the online store location (LocationId = 98).
+    # If LocationId is not provided, it will default to 98.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [String] request_client_id Optional parameter: The client ID
+    # @param [Integer] request_location_id Optional parameter: The location ID
+    # Default: **null** (Online store location)
+    # @return [GetAlternativePaymentMethodsResponse] Response from the API call.
+    def get_alternative_payment_methods(version,
+                                        site_id,
+                                        authorization: nil,
+                                        request_client_id: nil,
+                                        request_location_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/alternativepaymentmethods',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_client_id, key: 'request.clientId'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAlternativePaymentMethodsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Returns the contracts and autopay options that are available on a
+    # location-by-location basis. Depending on the configurations established by
+    # the site, this endpoint returns options that can be used to sign up
+    # clients for recurring payments for services offered by the business.
+    # @param [String] version Required parameter: version of the api.
+    # @param [Integer] request_location_id Required parameter: The ID of the
+    # location that has the requested contracts and AutoPay options.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Array[Integer]] request_contract_ids Optional parameter: When
+    # included, the response only contains details about the specified contract
+    # IDs.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [String] request_promo_code Optional parameter: PromoCode to
+    # apply
+    # @param [TrueClass | FalseClass] request_sold_online Optional parameter:
+    # When `true`, the response only contains details about contracts and
+    # AutoPay options that can be sold online.   When `false`, all contracts are
+    # returned.  Default: **false**
+    # @param [Integer] request_unique_client_id Optional parameter: The ID of
+    # the client.
+    # @return [GetContractsResponse] Response from the API call.
+    def get_contracts(version,
+                      request_location_id,
+                      site_id,
+                      authorization: nil,
+                      request_contract_ids: nil,
+                      request_limit: nil,
+                      request_offset: nil,
+                      request_promo_code: nil,
+                      request_sold_online: nil,
+                      request_unique_client_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/contracts',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_contract_ids, key: 'request.contractIds'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_promo_code, key: 'request.promoCode'))
+                   .query_param(new_parameter(request_sold_online, key: 'request.soldOnline'))
+                   .query_param(new_parameter(request_unique_client_id, key: 'request.uniqueClientId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetContractsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get payment methods that can be used to pay for sales at a site.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @return [GetCustomPaymentMethodsResponse] Response from the API call.
+    def get_custom_payment_methods(version,
+                                   site_id,
+                                   authorization: nil,
+                                   request_limit: nil,
+                                   request_offset: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/custompaymentmethods',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetCustomPaymentMethodsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Returns a gift card’s remaining balance.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [String] barcode_id Optional parameter: The barcode ID of the gift
+    # card for which you want the balance.
+    # @return [GetGiftCardBalanceResponse] Response from the API call.
+    def get_gift_card_balance(version,
+                              site_id,
+                              authorization: nil,
+                              barcode_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/giftcardbalance',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(barcode_id, key: 'barcodeId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetGiftCardBalanceResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Returns information about gift cards that can be purchased.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Array[Integer]] request_ids Optional parameter: Filters the
+    # results to the requested gift card IDs.<br />  Default: **all** gift
+    # cards.
+    # @param [TrueClass | FalseClass] request_include_custom_layouts Optional
+    # parameter: When `true`, includes custom gift card layouts.<br />  When
+    # `false`, includes only system layouts.  Default: **false**
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_location_id Optional parameter: When included,
+    # returns gift cards that are sold at the provided location ID.
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [TrueClass | FalseClass] request_sold_online Optional parameter:
+    # When `true`, only returns gift cards that are sold online.<br />  Default:
+    # **false**
+    # @return [GetGiftCardResponse] Response from the API call.
+    def get_gift_cards(version,
+                       site_id,
+                       authorization: nil,
+                       request_ids: nil,
+                       request_include_custom_layouts: nil,
+                       request_limit: nil,
+                       request_location_id: nil,
+                       request_offset: nil,
+                       request_sold_online: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/giftcards',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_ids, key: 'request.ids'))
+                   .query_param(new_parameter(request_include_custom_layouts, key: 'request.includeCustomLayouts'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_sold_online, key: 'request.soldOnline'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetGiftCardResponse.method(:from_hash)))
+        .execute
+    end
+
+    # A package is typically used to combine multiple services and/or products
+    # into a single offering. Staff members can check out multiple appointments
+    # while selling the package, and can discount the items included. For
+    # example, a spa might bundle a massage, a pedicure, a manicure, a facial,
+    # and a few selected beauty products into a package.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_location_id Optional parameter: The location ID
+    # to use to determine the tax for the products that this request returns.<br
+    # />  Default: **online store**
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Array[Integer]] request_package_ids Optional parameter: A list of
+    # the packages IDs to filter by.
+    # @param [TrueClass | FalseClass] request_sell_online Optional parameter:
+    # When `true`, only returns products that can be sold online.<br />  When
+    # `false`, all products are returned.<br />  Default: **false**
+    # @return [GetPackagesResponse] Response from the API call.
+    def get_packages(version,
+                     site_id,
+                     authorization: nil,
+                     request_limit: nil,
+                     request_location_id: nil,
+                     request_offset: nil,
+                     request_package_ids: nil,
+                     request_sell_online: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/packages',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_package_ids, key: 'request.packageIds'))
+                   .query_param(new_parameter(request_sell_online, key: 'request.sellOnline'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetPackagesResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get retail products available for purchase at a site.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Array[Integer]] request_category_ids Optional parameter: A list of
+    # revenue category IDs to filter by. Use this ID when calling the GET
+    # Categories endpoint.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_location_id Optional parameter: The location ID
+    # to use to determine the tax for the products that this request returns.<br
+    # />  Default: **online store**
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Array[String]] request_product_ids Optional parameter: The barcode
+    # number of the product to be filter by.
+    # @param [String] request_search_text Optional parameter: A search filter,
+    # used for searching by term.
+    # @param [Array[Integer]] request_secondary_category_ids Optional parameter:
+    # A list of secondary categories to filter by. Use this ID when calling the
+    # GET Categories endpoint.
+    # @param [TrueClass | FalseClass] request_sell_online Optional parameter:
+    # When `true`, only products that can be sold online are returned.<br />
+    # When `false`, all products are returned.<br />  Default: **false**
+    # @param [Array[Integer]] request_sub_category_ids Optional parameter: A
+    # list of subcategory IDs to filter by. Use this ID when calling the GET
+    # Categories endpoint.
+    # @return [GetProductsResponse] Response from the API call.
+    def get_products(version,
+                     site_id,
+                     authorization: nil,
+                     request_category_ids: nil,
+                     request_limit: nil,
+                     request_location_id: nil,
+                     request_offset: nil,
+                     request_product_ids: nil,
+                     request_search_text: nil,
+                     request_secondary_category_ids: nil,
+                     request_sell_online: nil,
+                     request_sub_category_ids: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/products',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_category_ids, key: 'request.categoryIds'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_product_ids, key: 'request.productIds'))
+                   .query_param(new_parameter(request_search_text, key: 'request.searchText'))
+                   .query_param(new_parameter(request_secondary_category_ids, key: 'request.secondaryCategoryIds'))
+                   .query_param(new_parameter(request_sell_online, key: 'request.sellOnline'))
+                   .query_param(new_parameter(request_sub_category_ids, key: 'request.subCategoryIds'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetProductsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Update retail products available for purchase at a site.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [Array[UpdateProductRequest]] update_products_requests Required
+    # parameter: TODO: type description here
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [GetProductsResponse] Response from the API call.
+    def update_products(version,
+                        site_id,
+                        update_products_requests,
+                        authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/public/v{version}/sale/products',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .body_param(new_parameter(update_products_requests))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetProductsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get retail products inventory data available at a site.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Array[String]] request_barcode_ids Optional parameter: When
+    # included, the response only contains details about the specified Barcode
+    # Ids.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Array[Integer]] request_location_ids Optional parameter: When
+    # included, the response only contains details about the specified location
+    # Ids.
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Array[String]] request_product_ids Optional parameter: When
+    # included, the response only contains details about the specified product
+    # Ids.
+    # @return [GetProductsInventoryResponse] Response from the API call.
+    def get_products_inventory(version,
+                               site_id,
+                               authorization: nil,
+                               request_barcode_ids: nil,
+                               request_limit: nil,
+                               request_location_ids: nil,
+                               request_offset: nil,
+                               request_product_ids: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/productsinventory',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_barcode_ids, key: 'request.barcodeIds'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_ids, key: 'request.locationIds'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_product_ids, key: 'request.productIds'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetProductsInventoryResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetches the status of an initiate purchase contract given accessToken.
+    # This endpoint complements the `Initiate Purchase Contract Using
+    # Alternative Payments` endpoint. `Initiate Purchase Contract Using
+    # Alternative Payments` endpoint will capture the intent to purchase a
+    # contract, and return a redirect URL for the end user to make the payment.
+    # Once the payment concludes, the end user will be redirected back to the
+    # PaymentAuthenticationCallbackUrl, which was provided while invoking the
+    # `Initiate Purchase Contract Using Alternative Payments` endpoint. You can
+    # then invoke this endpoint to obtain the `PurchaseContractResponse`.
+    # 
+    # **For a comprehensive guide, follow this tutorial:** [Purchase a
+    # Contract](https://developers.mindbodyonline.com/ui/documentation/public-ap
+    # i#/http/tutorials/purchase-a-contract)
+    # 
+    # The currently supported alternative payments are:
+    # - iDEAL
+    # - Apple Pay
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] access_token Required parameter: TODO: type description
+    # here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [PurchaseContractResponse] Response from the API call.
+    def get_purchase_contract_status(version,
+                                     access_token,
+                                     site_id,
+                                     authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/purchasecontractstatus',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .query_param(new_parameter(access_token, key: 'accessToken'))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PurchaseContractResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get sales completed at a site.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [DateTime] request_end_sale_date_time Optional parameter: Filters
+    # results to sales that happened before this date and time.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Integer] request_payment_method_id Optional parameter: Filters
+    # results to sales paid for by the given payment method ID which indicates
+    # payment method(s) (i.e. cash, VISA, AMEX, Check, etc.).
+    # @param [Integer] request_sale_id Optional parameter: The sale ID
+    # associated with the particular item. It Filters results to the requested
+    # sale ID.
+    # @param [DateTime] request_start_sale_date_time Optional parameter: Filters
+    # results to sales that happened after this date and time.
+    # @return [GetSalesResponse] Response from the API call.
+    def get_sales(version,
+                  site_id,
+                  authorization: nil,
+                  request_end_sale_date_time: nil,
+                  request_limit: nil,
+                  request_offset: nil,
+                  request_payment_method_id: nil,
+                  request_sale_id: nil,
+                  request_start_sale_date_time: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/sales',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_end_sale_date_time, key: 'request.endSaleDateTime'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_payment_method_id, key: 'request.paymentMethodId'))
+                   .query_param(new_parameter(request_sale_id, key: 'request.saleId'))
+                   .query_param(new_parameter(request_start_sale_date_time, key: 'request.startSaleDateTime'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetSalesResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get pricing options available for purchase at a site
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Integer] request_class_id Optional parameter: Filters to the
+    # pricing options for the specified class ID.
+    # @param [Integer] request_class_schedule_id Optional parameter: Filters to
+    # the pricing options for the specified class schedule ID.
+    # @param [TrueClass | FalseClass] request_hide_related_programs Optional
+    # parameter: When `true`, indicates that pricing options of related programs
+    # are omitted from the response.<br />  Default: **false**
+    # @param [TrueClass | FalseClass] request_include_discontinued Optional
+    # parameter: When `true`, indicates that the filtered pricing option list
+    # includes discontinued pricing options.<br />  Default: **false**
+    # @param [TrueClass | FalseClass] request_include_sale_in_contract_only
+    # Optional parameter: When `true`, indicates that the filtered pricing
+    # option list includes sale in contract only pricing options.<br />
+    # Default: **false**
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_location_id Optional parameter: When specified,
+    # for each returned pricing option, `TaxRate` and `TaxIncluded` are
+    # calculated according to the specified location. Note that this does not
+    # filter results to only services provided at the given location, and for
+    # locations where Value-Added Tax (VAT) rules apply, the `TaxRate` is set to
+    # zero.
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Array[Integer]] request_program_ids Optional parameter: Filters to
+    # pricing options with the specified program IDs.
+    # @param [TrueClass | FalseClass] request_sell_online Optional parameter:
+    # When `true`, filters the pricing options to display only those available
+    # for online purchase.  This parameter is only applicable in Business Mode
+    # (when a staff authentication header is included) and ignored in Consumer
+    # Mode (when no authentication header is passed).  <br />Default: `false`
+    # (for staff users)  <br />Business Mode: This parameter controls the
+    # filtering behavior. Staff users can set this to `true`  to show only
+    # pricing options that can be sold online, or `false` to show all available
+    # pricing options.  <br />Consumer Mode: This value is automatically set to
+    # `true` and cannot be overridden,  ensuring consumers only see pricing
+    # options available for online purchase.
+    # @param [Array[String]] request_service_ids Optional parameter: Filters to
+    # the pricing options with the specified IDs. In this context, service and
+    # pricing option are used interchangeably. These are the
+    # `PurchasedItems[].Id` returned from GET Sales.
+    # @param [Array[Integer]] request_session_type_ids Optional parameter:
+    # Filters to the pricing options with the specified session types IDs.
+    # @param [Integer] request_staff_id Optional parameter: Sets `Price` and
+    # `OnlinePrice` to the particular pricing of a specific staff member, if
+    # allowed by the business.
+    # @return [GetServicesResponse] Response from the API call.
+    def get_services(version,
+                     site_id,
+                     authorization: nil,
+                     request_class_id: nil,
+                     request_class_schedule_id: nil,
+                     request_hide_related_programs: nil,
+                     request_include_discontinued: nil,
+                     request_include_sale_in_contract_only: nil,
+                     request_limit: nil,
+                     request_location_id: nil,
+                     request_offset: nil,
+                     request_program_ids: nil,
+                     request_sell_online: nil,
+                     request_service_ids: nil,
+                     request_session_type_ids: nil,
+                     request_staff_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/services',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_class_id, key: 'request.classId'))
+                   .query_param(new_parameter(request_class_schedule_id, key: 'request.classScheduleId'))
+                   .query_param(new_parameter(request_hide_related_programs, key: 'request.hideRelatedPrograms'))
+                   .query_param(new_parameter(request_include_discontinued, key: 'request.includeDiscontinued'))
+                   .query_param(new_parameter(request_include_sale_in_contract_only, key: 'request.includeSaleInContractOnly'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_program_ids, key: 'request.programIds'))
+                   .query_param(new_parameter(request_sell_online, key: 'request.sellOnline'))
+                   .query_param(new_parameter(request_service_ids, key: 'request.serviceIds'))
+                   .query_param(new_parameter(request_session_type_ids, key: 'request.sessionTypeIds'))
+                   .query_param(new_parameter(request_staff_id, key: 'request.staffId'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetServicesResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Update unit price and online price of provided services.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [Array[UpdateServiceRequest]] update_services_request Required
+    # parameter: TODO: type description here
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [UpdateServiceResponse] Response from the API call.
+    def update_services(version,
+                        site_id,
+                        update_services_request,
+                        authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/public/v{version}/sale/services',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .body_param(new_parameter(update_services_request))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateServiceResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint returns a list of transaction details of processed sales.
+    # @param [String] version Required parameter: version of the api.
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @param [Integer] request_client_id Optional parameter: Filters results to
+    # the requested client ID.
+    # @param [Integer] request_limit Optional parameter: Number of results to
+    # include, defaults to 100
+    # @param [Integer] request_location_id Optional parameter: Filters the
+    # transaction results with the ID number associated with the location of the
+    # sale.
+    # @param [Integer] request_offset Optional parameter: Page offset, defaults
+    # to 0.
+    # @param [Integer] request_sale_id Optional parameter: Filters the
+    # transaction results with the ID number associated with the sale.
+    # @param [String] request_status Optional parameter: Filters the transaction
+    # results by the estimated transaction status.
+    # @param [DateTime] request_transaction_end_date_time Optional parameter:
+    # Filters the transaction results that happpened before this date and time.
+    #  Default: **today’s date**
+    # @param [Integer] request_transaction_id Optional parameter: Filters the
+    # transaction results with the ID number generated when the sale is
+    # processed.
+    # @param [DateTime] request_transaction_start_date_time Optional parameter:
+    # Filters the transaction results that happpened after this date and time.
+    # Default: **today’s date**
+    # @return [GetTransactionsResponse] Response from the API call.
+    def get_transactions(version,
+                         site_id,
+                         authorization: nil,
+                         request_client_id: nil,
+                         request_limit: nil,
+                         request_location_id: nil,
+                         request_offset: nil,
+                         request_sale_id: nil,
+                         request_status: nil,
+                         request_transaction_end_date_time: nil,
+                         request_transaction_id: nil,
+                         request_transaction_start_date_time: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/public/v{version}/sale/transactions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .query_param(new_parameter(request_client_id, key: 'request.clientId'))
+                   .query_param(new_parameter(request_limit, key: 'request.limit'))
+                   .query_param(new_parameter(request_location_id, key: 'request.locationId'))
+                   .query_param(new_parameter(request_offset, key: 'request.offset'))
+                   .query_param(new_parameter(request_sale_id, key: 'request.saleId'))
+                   .query_param(new_parameter(request_status, key: 'request.status'))
+                   .query_param(new_parameter(request_transaction_end_date_time, key: 'request.transactionEndDateTime'))
+                   .query_param(new_parameter(request_transaction_id, key: 'request.transactionId'))
+                   .query_param(new_parameter(request_transaction_start_date_time, key: 'request.transactionStartDateTime'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetTransactionsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint provides a wide range of functionality. For example, you can
+    # use it when a client purchases new pricing options, retail products,
+    # packages, and tips. You can also combine purchasing a new pricing option
+    # and many other functions, such as booking a client into a class, booking a
+    # new appointment for a client, enrolling a client into an enrollment or
+    # course, or reconciling an unpaid, already booked appointment or class. Use
+    # this call when a client purchases:
+    # * a pricing option, after calling `GET Services` and choosing a specific
+    # pricing option’s ID
+    # * a retail product, after calling `GET Products` and choosing a specific
+    # retail product’s ID
+    # * a package, after calling `GET Packages` and choosing a specific
+    # package’s ID
+    # * a tip to give to a staff member, after calling `GET Staff` and choosing
+    # a specific staff member ID, and the amount that the client wants to tip
+    # The documentation provides explanations of the request body and response,
+    # as well as the cart item metadata, payment item metadata, and purchased
+    # cart items.
+    # This endpoint had been updated to support Strong Customer Authentication
+    # (SCA).
+    # **Note :**
+    # Protect yourself from processor fees and credit card fraud.Remember to
+    # always protect your web forms that leverage POST CheckoutShoppingCart,
+    # POST PurchaseContract or POST PurchaseGiftCard with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [CheckoutShoppingCartRequest] request Required parameter: TODO:
+    # type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [CheckoutShoppingCartResponse] Response from the API call.
+    def checkout_shopping_cart(version,
+                               request,
+                               site_id,
+                               authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/checkoutshoppingcart',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CheckoutShoppingCartResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint complements the InitiateCheckoutShoppintCart endpoint.
+    # Please visit its documentation to understand further.
+    # The currently supported alternative payments are:
+    # - iDEAL
+    # - Apple Pay
+    # **How to use :**
+    # InitiateCheckoutShoppingCart and CompleteCheckoutShoppingCart endpoints
+    # work together. InitiateCheckoutShoppingCart endpoint will capture the
+    # intent to perform a checkout, and return a redirect URL for the end user
+    # to make the payment. Once the payment concludes, the end user will be
+    # redirected back to the PaymentAuthenticationCallbackUrl, which was
+    # provided while invoking the InitiateCheckoutShoppingCart endpoint. You can
+    # then invoke the CompleteCheckoutShoppingCart endpoint to complete the
+    # remaining checkout activities and obtain the CheckoutShoppingCartResponse.
+    # **For a comprehensive guide, follow this tutorial:** [Checkout Shopping
+    # Cart Using Alternative
+    # Payments](https://developers.mindbodyonline.com/ui/documentation/public-ap
+    # i#/http/tutorials/checkout-shopping-cart-using-alternative-payments)
+    # **Notes:**
+    # - This endpoint is only available for Studios on MBPS (Mindbody Payments)
+    # with Stripe payment processor.
+    # - Protect yourself from processor fees. Remember to always protect your
+    # web forms that leverage POST InitiateCheckoutShoppingCart or POST
+    # CompleteCheckoutShoppingCart with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [CompleteCheckoutShoppingCartUsingAlternativePaymentsRequest]
+    # request Required parameter: TODO: type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [CheckoutShoppingCartResponse] Response from the API call.
+    def complete_checkout_shopping_cart_using_alternative_payments(version,
+                                                                   request,
+                                                                   site_id,
+                                                                   authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/completecheckoutshoppingcart',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CheckoutShoppingCartResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint provides a wide range of functionality. For example, you can
+    # use it when a client purchases new pricing options, retail products,
+    # packages, and tips. You can also combine purchasing a new pricing option
+    # and many other functions, such as booking a client into a class, booking a
+    # new appointment for a client, enrolling a client into an enrollment or
+    # course, or reconciling an unpaid, already booked appointment or class. Use
+    # this call when a client purchases:
+    # * a pricing option, after calling `GET Services` and choosing a specific
+    # pricing option’s ID
+    # * a retail product, after calling `GET Products` and choosing a specific
+    # retail product’s ID
+    # * a package, after calling `GET Packages` and choosing a specific
+    # package’s ID
+    # * a tip to give to a staff member, after calling `GET Staff` and choosing
+    # a specific staff member ID, and the amount that the client wants to tip
+    # The documentation provides explanations of the request body and response,
+    # as well as the cart item metadata, payment item metadata, and purchased
+    # cart items.
+    # The currently supported alternative payments are:
+    # - iDEAL
+    # - Apple Pay
+    # 
+    # **How to use :**
+    # InitiateCheckoutShoppingCart and CompleteCheckoutShoppingCart endpoints
+    # work together. InitiateCheckoutShoppingCart endpoint will capture the
+    # intent to perform a checkout, and return a redirect URL for the end user
+    # to make the payment. Once the payment concludes, the end user will be
+    # redirected back to the PaymentAuthenticationCallbackUrl, which was
+    # provided while invoking the InitiateCheckoutShoppingCart endpoint. You can
+    # then invoke the CompleteCheckoutShoppingCart endpoint to complete the
+    # remaining checkout activities and obtain the CheckoutShoppingCartResponse.
+    # **For a comprehensive guide, follow this tutorial:** [Checkout Shopping
+    # Cart Using Alternative
+    # Payments](https://developers.mindbodyonline.com/ui/documentation/public-ap
+    # i#/http/tutorials/checkout-shopping-cart-using-alternative-payments)
+    # **Notes:**
+    # - This endpoint is only available for Studios on MBPS (Mindbody Payments)
+    # with Stripe payment processor.
+    # - This endpoint only supports the online store location (LocationId = 98).
+    # If LocationId is not provided, it will default to 98.
+    # - Product purchases are currently not supported on the online store
+    # location.
+    # - This endpoint only supports those payment methods as obtained from the
+    # GetAlternativePaymentMethods endpoint.
+    # - Protect yourself from processor fees. Remember to always protect your
+    # web forms that leverage POST InitiateCheckoutShoppingCart or POST
+    # CompleteCheckoutShoppingCart with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [InitiateCheckoutShoppingCartUsingAlternativePaymentsRequest]
+    # request Required parameter: TODO: type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [Object] Response from the API call.
+    def initiate_checkout_shopping_cart_using_alternative_payments(version,
+                                                                   request,
+                                                                   site_id,
+                                                                   authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/initiatecheckoutshoppingcart',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:json_deserialize)))
+        .execute
+    end
+
+    # Allows a client to sign up for a contract or autopay using the information
+    # returned from the `GET Contracts` endpoint. The client can pay with
+    # allowed alternative and local payment methods returned from `Get
+    # Alternative Payment Method`. The client must exist at the site specified
+    # before this call is made.
+    # 
+    # The currently supported alternative payments are:
+    # - iDEAL
+    # - Apple Pay
+    # 
+    # **For a comprehensive guide, follow this tutorial:** [Purchase a
+    # Contract](https://developers.mindbodyonline.com/ui/documentation/public-ap
+    # i#/http/tutorials/purchase-a-contract)
+    # 
+    # **Notes:**
+    # - This endpoint is only available for Studios on MBPS (Mindbody Payments)
+    # with Stripe payment processor.
+    # - This endpoint only supports the online store location (LocationId = 98).
+    # If LocationId is not provided, it will default to 98.
+    # - This endpoint only supports those payment methods as obtained from the
+    # GetAlternativePaymentMethods endpoint.
+    # - Protect yourself from processor fees and credit card fraud. Remember to
+    # always protect your web forms that leverage POST CheckoutShoppingCart,
+    # POST PurchaseContract or POST PurchaseGiftCard with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [InitiatePurchaseContractRequest] request Required parameter: TODO:
+    # type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [Object] Response from the API call.
+    def initiate_purchase_contract_using_alternative_payments(version,
+                                                              request,
+                                                              site_id,
+                                                              authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/initiatepurchasecontract',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:json_deserialize)))
+        .execute
+    end
+
+    # Allows a client to purchase account credit from a business.
+    # @param [String] version Required parameter: version of the api.
+    # @param [PurchaseAccountCreditRequest] request Required parameter: TODO:
+    # type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [PurchaseAccountCreditResponse] Response from the API call.
+    def purchase_account_credit(version,
+                                request,
+                                site_id,
+                                authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/purchaseaccountcredit',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PurchaseAccountCreditResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Allows a client to sign up for a contract or autopay using the information
+    # returned from the `GET Contracts` endpoint. The client can pay with a new
+    # credit card or with a stored credit card. The client must exist at the
+    # site specified before this call is made.
+    # This endpoint allows a developer to specify whether a client pays now or
+    # pays on the `StartDate`. If you are building a client-facing experience,
+    # you should talk with the business owner to understand the owner’s policies
+    # before you give clients a choice of the two payment types.
+    # This endpoint also allows a developer to specify a `ProrateDate`. If the
+    # date is passed, the Totals returned will always include the pro-rate
+    # amount for instant payment, like:
+    # - `FirstPaymentOccurs` = `Instant` =&gt; returns instant payment total for
+    # the contract + pro-rate amount.
+    # - `FirstPaymentOccurs` = `StartDate` =&gt; returns pro-rate amount +
+    # contract amount requiring instant payment. The rest of the contract will
+    # be due on `StartDate`.
+    # - Pro-rate amount payment on `StartDate` is not supported by this
+    # endpoint.
+    # This endpoint has been updated to support Strong Customer Authentication
+    # (SCA).
+    # **Note:**
+    # Protect yourself from processor fees and credit card fraud. Remember to
+    # always protect your web forms that leverage POST CheckoutShoppingCart,
+    # POST PurchaseContract or POST PurchaseGiftCard with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [PurchaseContractRequest] request Required parameter: TODO: type
+    # description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [PurchaseContractResponse] Response from the API call.
+    def purchase_contract(version,
+                          request,
+                          site_id,
+                          authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/purchasecontract',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PurchaseContractResponse.method(:from_hash)))
+        .execute
+    end
+
+    #  Allows a client to purchase a gift card from a business in a variety of
+    # designs. The card can be emailed to the recipient on a specific day, and a
+    # card title and a personal message can be added.
+    #  **Note**
+    # Protect yourself from processor fees and credit card fraud.Remember to
+    # always protect your web forms that leverage POST CheckoutShoppingCart,
+    # POST PurchaseContract or POST PurchaseGiftCard with a CAPTCHA!
+    # @param [String] version Required parameter: version of the api.
+    # @param [PurchaseGiftCardRequest] request Required parameter: TODO: type
+    # description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [PurchaseGiftCardResponse] Response from the API call.
+    def purchase_gift_card(version,
+                           request,
+                           site_id,
+                           authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/purchasegiftcard',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PurchaseGiftCardResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Return a comped sale for a specified sale ID in business mode. The sale is
+    # returnable only if it is a sale of a service, product or gift card and it
+    # has not been used. Currently, only the comp payment method is supported.
+    # @param [String] version Required parameter: version of the api.
+    # @param [ReturnSaleRequest] return_sale_request Required parameter: TODO:
+    # type description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [ReturnSaleResponse] Response from the API call.
+    def return_sale(version,
+                    return_sale_request,
+                    site_id,
+                    authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/returnsale',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(return_sale_request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ReturnSaleResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint updates the retail price and an online price for a product.
+    # Passing at least one of them is mandatory.
+    # @param [String] version Required parameter: version of the api.
+    # @param [UpdateProductPriceRequest] request Required parameter: TODO: type
+    # description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [UpdateProductPriceResponse] Response from the API call.
+    def update_product_price(version,
+                             request,
+                             site_id,
+                             authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/public/v{version}/sale/updateproductprice',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateProductPriceResponse.method(:from_hash)))
+        .execute
+    end
+
+    # This endpoint updates the SaleDate and returns the details of the sale.
+    # @param [String] version Required parameter: version of the api.
+    # @param [UpdateSaleDateRequest] request Required parameter: TODO: type
+    # description here
+    # @param [String] site_id Required parameter: ID of the site from which to
+    # pull data.
+    # @param [String] authorization Optional parameter: A staff user
+    # authorization token.
+    # @return [UpdateSaleDateResponse] Response from the API call.
+    def update_sale_date(version,
+                         request,
+                         site_id,
+                         authorization: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/public/v{version}/sale/updatesaledate',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(version, key: 'version')
+                                    .should_encode(true))
+                   .body_param(new_parameter(request))
+                   .header_param(new_parameter(site_id, key: 'siteId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(authorization, key: 'authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('API-Key')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateSaleDateResponse.method(:from_hash)))
+        .execute
+    end
+  end
+end