orb-apiamtic-sdk 0.0.1

data/lib/api_reference/apis/customer_api.rb

@@ -0,0 +1,1058 @@
+# api_reference
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ApiReference
+  # CustomerApi
+  class CustomerApi < BaseApi
+    # This endpoint returns a list of all customers for an account.
+    # The list of customers is ordered starting from the most recently created
+    # customer.
+    # This endpoint follows Orb's [standardized pagination
+    # format](/api-reference/pagination).
+    # See [Customer](/core-concepts##customer) for an overview of the customer
+    # model.
+    # @param [Integer] limit Optional parameter: Example:20
+    # @param [String] cursor Optional parameter: TODO: type description here
+    # @param [DateTime] created_at_gte Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] created_at_gt Optional parameter: TODO: type description
+    # here
+    # @param [DateTime] created_at_lt Optional parameter: TODO: type description
+    # here
+    # @param [DateTime] created_at_lte Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_customers(limit: 20,
+                       cursor: nil,
+                       created_at_gte: nil,
+                       created_at_gt: nil,
+                       created_at_lt: nil,
+                       created_at_lte: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(created_at_gte, key: 'created_at[gte]'))
+                   .query_param(new_parameter(created_at_gt, key: 'created_at[gt]'))
+                   .query_param(new_parameter(created_at_lt, key: 'created_at[lt]'))
+                   .query_param(new_parameter(created_at_lte, key: 'created_at[lte]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customers.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This operation is used to create an Orb customer, who is party to the core
+    # billing relationship. See
+    # [Customer](/core-concepts##customer) for an overview of the customer
+    # resource.
+    # This endpoint is critical in the following Orb functionality:
+    # * Automated charges can be configured by setting `payment_provider` and
+    # `payment_provider_id` to automatically
+    #   issue invoices
+    # * [Customer ID Aliases](/events-and-metrics/customer-aliases) can be
+    # configured by setting
+    #   `external_customer_id`
+    # * [Timezone localization](/essentials/timezones) can be configured on a
+    # per-customer basis by
+    #   setting the `timezone` parameter
+    # @param [NewCustomer] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_customer(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customer.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint is used to fetch customer details given an
+    # `external_customer_id` (see
+    # [Customer ID Aliases](/events-and-metrics/customer-aliases)).
+    # Note that the resource and semantics of this endpoint exactly mirror [Get
+    # Customer](fetch-customer).
+    # @param [String] external_customer_id Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def fetch_customer_external_id(external_customer_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers/external_customer_id/{external_customer_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(external_customer_id, key: 'external_customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customer.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint is used to update customer details given an
+    # `external_customer_id`
+    # (see [Customer ID Aliases](/events-and-metrics/customer-aliases)).
+    # Note that the resource and semantics of this endpoint exactly mirror
+    # [Update Customer](update-customer).
+    # @param [String] external_customer_id Required parameter: TODO: type
+    # description here
+    # @param [EditCustomer] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_customer_external_id(external_customer_id,
+                                    body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/customers/external_customer_id/{external_customer_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(external_customer_id, key: 'external_customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customer.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint is used to fetch a day-by-day snapshot of a customer's costs
+    # in Orb, calculated by applying pricing
+    # information to the underlying usage (see the [subscription usage
+    # endpoint](/api-reference/subscription/fetch-subscription-usage)
+    # to fetch usage per metric, in usage units rather than a currency).
+    # This endpoint can be leveraged for internal tooling and to provide a more
+    # transparent billing experience for your
+    # end users:
+    # 1. Understand the cost breakdown per line item historically and in
+    # real-time for the current billing period.
+    # 2. Provide customer visibility into how different services are
+    # contributing to the overall invoice with a per-day
+    #   timeseries (as compared to the [upcoming
+    # invoice](/api-reference/invoice/fetch-upcoming-invoice) resource,
+    #   which represents a snapshot for the current period).
+    # 3. Assess how minimums and discounts affect your customers by teasing
+    # apart costs directly as a result of usage,
+    #   as opposed to minimums and discounts at the plan and price level.
+    # 4. Gain insight into key customer health metrics, such as the percent
+    # utilization of the minimum committed spend.
+    # ## Fetching subscriptions
+    # By default, this endpoint fetches the currently active subscription for
+    # the customer, and returns cost information
+    # for the subscription's current billing period, broken down by each
+    # participating price. If there are no currently
+    # active subscriptions, this will instead default to the most recently
+    # active subscription or return an empty series
+    # if none are found. For example, if your plan charges for compute hours,
+    # job runs, and data syncs, then this endpoint
+    # would provide a daily breakdown of your customer's cost for each of those
+    # axes.
+    # If timeframe bounds are specified, Orb fetches all subscriptions that were
+    # active in that timeframe. If two
+    # subscriptions overlap on a single day, costs from each price will be
+    # summed, and prices for both subscriptions will
+    # be included in the breakdown.
+    # ## Prepaid plans
+    # For plans that include prices which deduct credits rather than accrue
+    # in-arrears charges in a billable currency,
+    # this endpoint will return the total deduction amount, in credits, for the
+    # specified timeframe.
+    # ## Cumulative subtotals and totals
+    # Since the subtotal and total must factor in any billing-period level
+    # discounts and minimums, it's most meaningful
+    # to consider costs relative to the start of the subscription's billing
+    # period. As a result, by default this endpoint
+    # returns cumulative totals since the beginning of the billing period. In
+    # particular, the `timeframe_start` of a
+    # returned timeframe window is *always* the beginning of the billing period
+    # and `timeframe_end` is incremented one day
+    # at a time to build the result.
+    # A customer that uses a few API calls a day but has a minimum commitment
+    # might exhibit the following pattern for
+    # their subtotal and total in the first few days of the month. Here, we
+    # assume that each API call is \$2.50, the
+    # customer's plan has a monthly minimum of \$50 for this price, and that the
+    # subscription's billing period bounds are
+    # aligned to the first of the month:
+    # | timeframe_start | timeframe_end | Cumulative usage | Subtotal | Total
+    # (incl. commitment)  |
+    # | -----------| ----------- | ----------- | ----------- |----------- |
+    # | 2023-02-01 | 2023-02-02 | 9 | \$22.50 | \$50.00 |
+    # | 2023-02-01 | 2023-02-03 | 19 | \$47.50 | \$50.00 |
+    # | 2023-02-01 | 2023-02-04 | 20 | \$50.00 | \$50.00 |
+    # | 2023-02-01 | 2023-02-05 | 28 | \$70.00 | \$70.00 |
+    # | 2023-02-01 | 2023-02-06 | 36 | \$90.00 | \$90.00 |
+    # ### Periodic values
+    # When the query parameter `view_mode=periodic` is specified, Orb will
+    # return an incremental day-by-day view of costs.
+    # In this case, there will always be a one-day difference between
+    # `timeframe_start` and `timeframe_end` for the
+    # timeframes returned. This is a transform on top of the cumulative costs,
+    # calculated by taking the difference of each
+    # timeframe with the last. Note that in the above example, the `Total` value
+    # would be 0 for the second two data
+    # points, since the minimum commitment has not yet been hit and each day is
+    # not contributing anything to the total
+    # cost.
+    # ## Timeframe bounds
+    # For an active subscription, both timeframes should be specified in the
+    # request. If a subscription starts or ends within the
+    # timeframe, the response will only include windows where the subscription
+    # is active. If a subscription has ended, no timeframe
+    # bounds need to be specified and the response will default to the billing
+    # period when the subscription was last active.
+    # As noted above, `timeframe_start` for a given cumulative datapoint is
+    # always the beginning of the billing period,
+    # and `timeframe_end` is incremented one day at a time to construct the
+    # response. When a timeframe is passed in that
+    # is not aligned to the current subscription's billing period, the response
+    # will contain cumulative totals from
+    # multiple billing periods.
+    # Suppose the queried customer has a subscription aligned to the 15th of
+    # every month. If this endpoint is queried with
+    # the date range `2023-06-01` - `2023-07-01`, the first data point will
+    # represent about half a billing period's worth
+    # of costs, accounting for accruals from the start of the billing period and
+    # inclusive of the first day of the
+    # timeframe (`timeframe_start = 2023-05-15 00:00:00`, `timeframe_end =
+    # 2023-06-02 00:00:00`)
+    # | datapoint index | timeframe_start | timeframe_end |
+    # | ----------- | -----------| ----------- |
+    # | 0 | 2023-05-15 | 2023-06-02 |
+    # | 1 | 2023-05-15 | 2023-06-03 |
+    # | 2 | ... | ... |
+    # | 3 | 2023-05-15 | 2023-06-14 |
+    # | 4 | 2023-06-15 | 2023-06-16 |
+    # | 5 | 2023-06-15 | 2023-06-17 |
+    # | 6 | ... | ... |
+    # | 7 | 2023-06-15 | 2023-07-01 |
+    # You can see this sliced timeframe visualized
+    # [here](https://i.imgur.com/TXhYgme.png).
+    # ### Matrix prices
+    # When a price uses matrix pricing, it's important to view costs grouped by
+    # those matrix dimensions. Orb will return
+    # `price_groups` with the `grouping_key` and `secondary_grouping_key` based
+    # on the matrix price definition, for each
+    # `grouping_value` and `secondary_grouping_value` available.
+    # @param [String] external_customer_id Required parameter: TODO: type
+    # description here
+    # @param [DateTime] timeframe_start Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] timeframe_end Optional parameter: TODO: type description
+    # here
+    # @param [ViewMode] view_mode Optional parameter: Example:
+    # @param [String] currency Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def fetch_customer_costs_external_id(external_customer_id: nil,
+                                         timeframe_start: nil,
+                                         timeframe_end: nil,
+                                         view_mode: nil,
+                                         currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers/external_customer_id/{external_customer_id}/costs',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(external_customer_id, key: 'external_customer_id')
+                                    .should_encode(true))
+                   .query_param(new_parameter(timeframe_start, key: 'timeframe_start'))
+                   .query_param(new_parameter(timeframe_end, key: 'timeframe_end'))
+                   .query_param(new_parameter(view_mode, key: 'view_mode'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerCosts.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # Creates a portal session for the customer, returning a short-lived URL
+    # that provides
+    # authenticated access to the customer's billing portal. The session expires
+    # after
+    # `expires_in_minutes` (default 60, max 180). By default, creating a new
+    # session invalidates
+    # any other active portal sessions for the customer; pass
+    # `invalidate_existing=false` to
+    # allow concurrent sessions.
+    # @param [String] external_customer_id Required parameter: TODO: type
+    # description here
+    # @param [NewPortalSession] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_customer_portal_session_by_external_id(external_customer_id: nil,
+                                                      body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers/external_customer_id/{external_customer_id}/portal_sessions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(external_customer_id, key: 'external_customer_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PortalSession.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # Sync Orb's payment methods for the customer with their gateway.
+    # This method can be called before taking an action that may cause the
+    # customer to be charged, ensuring that the most up-to-date
+    # payment method is charged.
+    # **Note**: This functionality is currently only available for Stripe.
+    # @param [String] external_customer_id Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sync_customer_payment_methods_from_gateway_by_external_id(external_customer_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers/external_customer_id/{external_customer_id}/sync_payment_methods_from_gateway',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(external_customer_id, key: 'external_customer_id')
+                                    .should_encode(true))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint is used to fetch customer details given an identifier. If
+    # the `Customer` is in the process of being deleted,
+    # only the properties `id` and `deleted: true` will be returned.
+    # See the [Customer resource](/core-concepts#customer) for a full discussion
+    # of the Customer model.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def fetch_customer(customer_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers/{customer_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customer.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint can be used to update the `payment_provider`,
+    # `payment_provider_id`, `name`, `email`, `email_delivery`, `tax_id`,
+    # `auto_collection`, `metadata`, `shipping_address`, `billing_address`,
+    # `additional_emails`, and `currency` of an existing
+    # customer. `currency` can only be set if it has not already been set on the
+    # customer. Other fields on a customer are currently
+    # immutable.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @param [EditCustomer] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_customer(customer_id,
+                        body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/customers/{customer_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Customer.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This performs a deletion of this customer, its subscriptions, and its
+    # invoices, provided the customer does not have any issued
+    # invoices. Customers with issued invoices cannot be deleted. This operation
+    # is irreversible. Note that this
+    # is a _soft_ deletion, but the data will be inaccessible through the API
+    # and Orb dashboard.
+    # For a hard-deletion, please reach out to the Orb team directly.
+    # **Note**: This operation happens asynchronously and can be expected to
+    # take a
+    # few minutes to propagate to related resources. However, querying for the
+    # customer on
+    # subsequent GET requests while deletion is in process will reflect its
+    # deletion.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_customer(customer_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/customers/{customer_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # ## The customer balance
+    # The customer balance is an amount in the customer's currency, which Orb
+    # automatically applies to subsequent
+    # invoices. This balance can be adjusted manually via Orb's webapp on the
+    # customer details page. You can use this
+    # balance to provide a fixed mid-period credit to the customer. Commonly,
+    # this is done due to system downtime/SLA
+    # violation, or an adhoc adjustment discussed with the customer.
+    # If the balance is a positive value at the time of invoicing, it represents
+    # that the customer has credit that should
+    # be used to offset the amount due on the next issued invoice. In this case,
+    # Orb will automatically reduce the next
+    # invoice by the balance amount, and roll over any remaining balance if the
+    # invoice is fully discounted.
+    # If the balance is a negative value at the time of invoicing, Orb will
+    # increase the invoice's amount due with a
+    # positive adjustment, and reset the balance to 0.
+    # This endpoint retrieves all customer balance transactions in reverse
+    # chronological order for a single customer,
+    # providing a complete audit trail of all adjustments and invoice
+    # applications.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @param [Integer] limit Optional parameter: Example:20
+    # @param [String] cursor Optional parameter: TODO: type description here
+    # @param [DateTime] operation_time_gte Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] operation_time_gt Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] operation_time_lt Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] operation_time_lte Optional parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_balance_transactions(customer_id,
+                                  limit: 20,
+                                  cursor: nil,
+                                  operation_time_gte: nil,
+                                  operation_time_gt: nil,
+                                  operation_time_lt: nil,
+                                  operation_time_lte: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers/{customer_id}/balance_transactions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .query_param(new_parameter(cursor, key: 'cursor'))
+                   .query_param(new_parameter(operation_time_gte, key: 'operation_time[gte]'))
+                   .query_param(new_parameter(operation_time_gt, key: 'operation_time[gt]'))
+                   .query_param(new_parameter(operation_time_lt, key: 'operation_time[lt]'))
+                   .query_param(new_parameter(operation_time_lte, key: 'operation_time[lte]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerBalanceTransactions.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # Creates an immutable balance transaction that updates the customer's
+    # balance and returns back the newly created
+    # transaction.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @param [NewCustomerBalanceTransaction] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_customer_balance_transaction(customer_id,
+                                            body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers/{customer_id}/balance_transactions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerBalanceTransaction.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # This endpoint is used to fetch a day-by-day snapshot of a customer's costs
+    # in Orb, calculated by applying pricing
+    # information to the underlying usage (see the [subscription usage
+    # endpoint](/api-reference/subscription/fetch-subscription-usage)
+    # to fetch usage per metric, in usage units rather than a currency).
+    # This endpoint can be leveraged for internal tooling and to provide a more
+    # transparent billing experience for your
+    # end users:
+    # 1. Understand the cost breakdown per line item historically and in
+    # real-time for the current billing period.
+    # 2. Provide customer visibility into how different services are
+    # contributing to the overall invoice with a per-day
+    #   timeseries (as compared to the [upcoming
+    # invoice](/api-reference/invoice/fetch-upcoming-invoice) resource,
+    #   which represents a snapshot for the current period).
+    # 3. Assess how minimums and discounts affect your customers by teasing
+    # apart costs directly as a result of usage,
+    #   as opposed to minimums and discounts at the plan and price level.
+    # 4. Gain insight into key customer health metrics, such as the percent
+    # utilization of the minimum committed spend.
+    # ## Fetching subscriptions
+    # By default, this endpoint fetches the currently active subscription for
+    # the customer, and returns cost information
+    # for the subscription's current billing period, broken down by each
+    # participating price. If there are no currently
+    # active subscriptions, this will instead default to the most recently
+    # active subscription or return an empty series
+    # if none are found. For example, if your plan charges for compute hours,
+    # job runs, and data syncs, then this endpoint
+    # would provide a daily breakdown of your customer's cost for each of those
+    # axes.
+    # If timeframe bounds are specified, Orb fetches all subscriptions that were
+    # active in that timeframe. If two
+    # subscriptions overlap on a single day, costs from each price will be
+    # summed, and prices for both subscriptions will
+    # be included in the breakdown.
+    # ## Prepaid plans
+    # For plans that include prices which deduct credits rather than accrue
+    # in-arrears charges in a billable currency,
+    # this endpoint will return the total deduction amount, in credits, for the
+    # specified timeframe.
+    # ## Cumulative subtotals and totals
+    # Since the subtotal and total must factor in any billing-period level
+    # discounts and minimums, it's most meaningful
+    # to consider costs relative to the start of the subscription's billing
+    # period. As a result, by default this endpoint
+    # returns cumulative totals since the beginning of the billing period. In
+    # particular, the `timeframe_start` of a
+    # returned timeframe window is *always* the beginning of the billing period
+    # and `timeframe_end` is incremented one day
+    # at a time to build the result.
+    # A customer that uses a few API calls a day but has a minimum commitment
+    # might exhibit the following pattern for
+    # their subtotal and total in the first few days of the month. Here, we
+    # assume that each API call is \$2.50, the
+    # customer's plan has a monthly minimum of \$50 for this price, and that the
+    # subscription's billing period bounds are
+    # aligned to the first of the month:
+    # | timeframe_start | timeframe_end | Cumulative usage | Subtotal | Total
+    # (incl. commitment)  |
+    # | -----------| ----------- | ----------- | ----------- |----------- |
+    # | 2023-02-01 | 2023-02-02 | 9 | \$22.50 | \$50.00 |
+    # | 2023-02-01 | 2023-02-03 | 19 | \$47.50 | \$50.00 |
+    # | 2023-02-01 | 2023-02-04 | 20 | \$50.00 | \$50.00 |
+    # | 2023-02-01 | 2023-02-05 | 28 | \$70.00 | \$70.00 |
+    # | 2023-02-01 | 2023-02-06 | 36 | \$90.00 | \$90.00 |
+    # ### Periodic values
+    # When the query parameter `view_mode=periodic` is specified, Orb will
+    # return an incremental day-by-day view of costs.
+    # In this case, there will always be a one-day difference between
+    # `timeframe_start` and `timeframe_end` for the
+    # timeframes returned. This is a transform on top of the cumulative costs,
+    # calculated by taking the difference of each
+    # timeframe with the last. Note that in the above example, the `Total` value
+    # would be 0 for the second two data
+    # points, since the minimum commitment has not yet been hit and each day is
+    # not contributing anything to the total
+    # cost.
+    # ## Timeframe bounds
+    # For an active subscription, both timeframes should be specified in the
+    # request. If a subscription starts or ends within the
+    # timeframe, the response will only include windows where the subscription
+    # is active. If a subscription has ended, no timeframe
+    # bounds need to be specified and the response will default to the billing
+    # period when the subscription was last active.
+    # As noted above, `timeframe_start` for a given cumulative datapoint is
+    # always the beginning of the billing period,
+    # and `timeframe_end` is incremented one day at a time to construct the
+    # response. When a timeframe is passed in that
+    # is not aligned to the current subscription's billing period, the response
+    # will contain cumulative totals from
+    # multiple billing periods.
+    # Suppose the queried customer has a subscription aligned to the 15th of
+    # every month. If this endpoint is queried with
+    # the date range `2023-06-01` - `2023-07-01`, the first data point will
+    # represent about half a billing period's worth
+    # of costs, accounting for accruals from the start of the billing period and
+    # inclusive of the first day of the
+    # timeframe (`timeframe_start = 2023-05-15 00:00:00`, `timeframe_end =
+    # 2023-06-02 00:00:00`)
+    # | datapoint index | timeframe_start | timeframe_end |
+    # | ----------- | -----------| ----------- |
+    # | 0 | 2023-05-15 | 2023-06-02 |
+    # | 1 | 2023-05-15 | 2023-06-03 |
+    # | 2 | ... | ... |
+    # | 3 | 2023-05-15 | 2023-06-14 |
+    # | 4 | 2023-06-15 | 2023-06-16 |
+    # | 5 | 2023-06-15 | 2023-06-17 |
+    # | 6 | ... | ... |
+    # | 7 | 2023-06-15 | 2023-07-01 |
+    # You can see this sliced timeframe visualized
+    # [here](https://i.imgur.com/TXhYgme.png).
+    # ### Matrix prices
+    # When a price uses matrix pricing, it's important to view costs grouped by
+    # those matrix dimensions. Orb will return
+    # `price_groups` with the `grouping_key` and `secondary_grouping_key` based
+    # on the matrix price definition, for each
+    # `grouping_value` and `secondary_grouping_value` available.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @param [DateTime] timeframe_start Optional parameter: TODO: type
+    # description here
+    # @param [DateTime] timeframe_end Optional parameter: TODO: type description
+    # here
+    # @param [ViewMode] view_mode Optional parameter: Example:
+    # @param [String] currency Optional parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def fetch_customer_costs(customer_id: nil,
+                             timeframe_start: nil,
+                             timeframe_end: nil,
+                             view_mode: nil,
+                             currency: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customers/{customer_id}/costs',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .should_encode(true))
+                   .query_param(new_parameter(timeframe_start, key: 'timeframe_start'))
+                   .query_param(new_parameter(timeframe_end, key: 'timeframe_end'))
+                   .query_param(new_parameter(view_mode, key: 'view_mode'))
+                   .query_param(new_parameter(currency, key: 'currency'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CustomerCosts.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # Creates a portal session for the customer, returning a short-lived URL
+    # that provides
+    # authenticated access to the customer's billing portal. The session expires
+    # after
+    # `expires_in_minutes` (default 60, max 180). By default, creating a new
+    # session invalidates
+    # any other active portal sessions for the customer; pass
+    # `invalidate_existing=false` to
+    # allow concurrent sessions.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @param [NewPortalSession] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_customer_portal_session(customer_id: nil,
+                                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers/{customer_id}/portal_sessions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PortalSession.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+
+    # Sync Orb's payment methods for the customer with their gateway.
+    # This method can be called before taking an action that may cause the
+    # customer to be charged, ensuring that the most up-to-date
+    # payment method is charged.
+    # **Note**: This functionality is currently only available for Stripe.
+    # @param [String] customer_id Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def sync_customer_payment_methods_from_gateway(customer_id: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/customers/{customer_id}/sync_payment_methods_from_gateway',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(customer_id, key: 'customer_id')
+                                    .should_encode(true))
+                   .auth(Single.new('APIKeyAuth')))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 APIException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 AuthorizationErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 APIException)
+                    .local_error('409',
+                                 'Conflict',
+                                 IdempotencyRequestMismatchException)
+                    .local_error('413',
+                                 'Content Too Large',
+                                 APIException)
+                    .local_error('429',
+                                 'Too Many Requests',
+                                 TooManyRequestsException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ServerErrorException))
+        .execute
+    end
+  end
+end